#include <gmlib/number/internal/mpz_x64.h>
#if defined(NUMBER_IMPL_MPZ_X64)
#include <stdexcept>
#include <cstring>

using namespace number::internal::x64;

void test_mpz_x64_add_carry()
{
    uint64_t    augend[4], addend[4], sum[4];
    int          carry;
    std::uint8_t sum_data[32];

    static std::uint8_t augend0[32] = {0x7f,0xab,0xee,0x97,0x56,0xf4,0x60,0xfd,0x22,0xdd,0xc8,0x5e,0x5c,0x74,0x01,0xcf,0x3c,0xde,0xe6,0xa3,0x6a,0xc7,0xfa,0x15,0xaa,0xe7,0xc0,0x19,0x0a,0x70,0xf8,0xf1};
    static std::uint8_t addend0[32] = {0x80,0xe3,0x06,0x31,0x44,0x9a,0x73,0xe6,0x7d,0x7b,0x12,0x67,0x65,0x02,0xbf,0x80,0xfe,0x92,0x10,0xfd,0xab,0xb3,0xcd,0x19,0x35,0xac,0xa4,0x1f,0xa2,0x75,0x28,0x0e};
    static std::uint8_t sum0[32]    = {0x00,0x8e,0xf4,0xc8,0x9b,0x8e,0xd4,0xe3,0xa0,0x58,0xda,0xc5,0xc1,0x76,0xc1,0x50,0x3b,0x70,0xf7,0xa1,0x16,0x7b,0xc7,0x2e,0xe0,0x94,0x64,0x38,0xac,0xe6,0x20,0xff};
    static int          carry0      = 1;
    mpz_from_bytes(augend, augend0, 4);
    mpz_from_bytes(addend, addend0, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum0, sum_data, 32) != 0 || carry0 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend1[32] = {0xd9,0x38,0xe1,0x07,0xbb,0x81,0x0e,0x5e,0xa3,0x43,0x19,0x1b,0x7d,0xa2,0x4e,0x1b,0xb0,0x9e,0x6d,0x03,0x4b,0x03,0x12,0x61,0x0a,0x28,0x84,0x62,0x42,0x86,0x7b,0x43};
    static std::uint8_t addend1[32] = {0x4c,0x77,0xde,0x36,0x97,0x14,0xec,0xb3,0x1d,0x5f,0x66,0xa9,0x29,0x34,0x9e,0x5b,0xe6,0xc1,0xb9,0x48,0x04,0x43,0xf3,0x62,0x02,0x34,0xe0,0x4f,0xbe,0x12,0x6a,0x84};
    static std::uint8_t sum1[32]    = {0x25,0xb0,0xbf,0x3e,0x52,0x95,0xfb,0x11,0xc0,0xa2,0x7f,0xc4,0xa6,0xd6,0xec,0x77,0x97,0x60,0x26,0x4b,0x4f,0x47,0x05,0xc3,0x0c,0x5d,0x64,0xb2,0x00,0x98,0xe5,0xc7};
    static int          carry1      = 1;
    mpz_from_bytes(augend, augend1, 4);
    mpz_from_bytes(addend, addend1, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum1, sum_data, 32) != 0 || carry1 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend2[32] = {0x33,0x5a,0xd0,0xe3,0xbc,0x43,0xcd,0x20,0xcd,0x92,0xbd,0x70,0xad,0x16,0x71,0x9a,0xad,0xbe,0x1a,0x25,0x1b,0x59,0x90,0x2a,0x7c,0x92,0x69,0xda,0x9a,0x0b,0xb2,0x1a};
    static std::uint8_t addend2[32] = {0x8e,0xdb,0x06,0x56,0x9a,0xd8,0xc6,0x12,0x6c,0xa5,0x0e,0xa3,0x1d,0xbe,0x94,0xce,0xcd,0xa2,0x1c,0xcb,0xe5,0x27,0x5d,0x9b,0x94,0x36,0x9b,0x53,0xf2,0xae,0x26,0x29};
    static std::uint8_t sum2[32]    = {0xc2,0x35,0xd7,0x3a,0x57,0x1c,0x93,0x33,0x3a,0x37,0xcc,0x13,0xca,0xd5,0x06,0x69,0x7b,0x60,0x36,0xf1,0x00,0x80,0xed,0xc6,0x10,0xc9,0x05,0x2e,0x8c,0xb9,0xd8,0x43};
    static int          carry2      = 0;
    mpz_from_bytes(augend, augend2, 4);
    mpz_from_bytes(addend, addend2, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum2, sum_data, 32) != 0 || carry2 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend3[32] = {0x52,0xba,0x31,0xbd,0x8c,0xfd,0x16,0x34,0xd6,0x09,0x47,0xb8,0x2f,0xa2,0x4c,0xd3,0x0a,0xf5,0x4b,0xa0,0xfd,0x98,0x53,0x25,0xbd,0x4e,0xf3,0x48,0x73,0x89,0x21,0xbb};
    static std::uint8_t addend3[32] = {0xfa,0x3b,0xd8,0xce,0x19,0x73,0xe1,0xbb,0x4b,0x1b,0x1a,0xaa,0x86,0xa3,0x1c,0xe3,0xdc,0x8e,0xf6,0x60,0xd1,0x3b,0x3f,0xb4,0xa8,0xd7,0xa5,0x21,0xb3,0x65,0x9c,0x00};
    static std::uint8_t sum3[32]    = {0x4c,0xf6,0x0a,0x8b,0xa6,0x70,0xf7,0xf0,0x21,0x24,0x62,0x62,0xb6,0x45,0x69,0xb6,0xe7,0x84,0x42,0x01,0xce,0xd3,0x92,0xda,0x66,0x26,0x98,0x6a,0x26,0xee,0xbd,0xbb};
    static int          carry3      = 1;
    mpz_from_bytes(augend, augend3, 4);
    mpz_from_bytes(addend, addend3, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum3, sum_data, 32) != 0 || carry3 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend4[32] = {0xf7,0x3b,0x65,0x98,0xcf,0xb4,0x93,0x84,0x23,0x36,0xbd,0x7a,0x44,0x9c,0x68,0x66,0xf1,0x6e,0x29,0xbd,0x68,0x98,0x0a,0x73,0x35,0x65,0xc4,0x61,0x27,0x75,0x88,0xa4};
    static std::uint8_t addend4[32] = {0x47,0x96,0xb5,0xa2,0xe2,0x51,0x0e,0x00,0xc9,0x93,0x89,0xc5,0xbb,0xd0,0x63,0xc4,0xbc,0x01,0xe4,0x51,0xaf,0x94,0xa1,0xcd,0xf1,0xd0,0x1c,0x26,0x1f,0x50,0xdd,0xdd};
    static std::uint8_t sum4[32]    = {0x3e,0xd2,0x1b,0x3b,0xb2,0x05,0xa1,0x84,0xec,0xca,0x47,0x40,0x00,0x6c,0xcc,0x2b,0xad,0x70,0x0e,0x0f,0x18,0x2c,0xac,0x41,0x27,0x35,0xe0,0x87,0x46,0xc6,0x66,0x81};
    static int          carry4      = 1;
    mpz_from_bytes(augend, augend4, 4);
    mpz_from_bytes(addend, addend4, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum4, sum_data, 32) != 0 || carry4 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend5[32] = {0xf6,0x89,0xfe,0x71,0x66,0x4c,0x1d,0x19,0x8f,0x49,0xb8,0xbb,0x70,0xa0,0xe9,0x0d,0xf1,0xe8,0x41,0xc9,0x12,0xae,0xd2,0xec,0x45,0x5a,0x0c,0x5f,0xf4,0x7f,0x9c,0x7b};
    static std::uint8_t addend5[32] = {0x8b,0xe7,0x5f,0x6c,0x87,0x76,0xe2,0x7a,0xf5,0x03,0xfa,0x70,0x22,0x2a,0x37,0x07,0x16,0xf4,0xae,0x4f,0x46,0xab,0x9a,0x9b,0xc6,0x13,0x39,0x81,0x09,0xeb,0x07,0x59};
    static std::uint8_t sum5[32]    = {0x82,0x71,0x5d,0xdd,0xed,0xc2,0xff,0x94,0x84,0x4d,0xb3,0x2b,0x92,0xcb,0x20,0x15,0x08,0xdc,0xf0,0x18,0x59,0x5a,0x6d,0x88,0x0b,0x6d,0x45,0xe0,0xfe,0x6a,0xa3,0xd4};
    static int          carry5      = 1;
    mpz_from_bytes(augend, augend5, 4);
    mpz_from_bytes(addend, addend5, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum5, sum_data, 32) != 0 || carry5 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend6[32] = {0x9a,0x10,0x3d,0xf1,0x32,0x1c,0xac,0xb8,0xef,0x6a,0xbd,0xd7,0x0f,0x3a,0xf6,0x4c,0x29,0x4b,0xf3,0x57,0xaa,0x8e,0xcb,0xaf,0x67,0xcc,0xcf,0x4f,0x81,0x0c,0x46,0x98};
    static std::uint8_t addend6[32] = {0xac,0xb9,0xaf,0x1c,0x78,0x20,0x4c,0x30,0xc2,0xeb,0x9b,0x2f,0xcb,0xc5,0x72,0x9c,0xcb,0xe7,0x84,0xe8,0xf5,0x63,0xa3,0x30,0x27,0xe8,0x49,0xd6,0xb5,0x95,0x1e,0x96};
    static std::uint8_t sum6[32]    = {0x46,0xc9,0xed,0x0d,0xaa,0x3c,0xf8,0xe9,0xb2,0x56,0x59,0x06,0xdb,0x00,0x68,0xe8,0xf5,0x33,0x78,0x40,0x9f,0xf2,0x6e,0xdf,0x8f,0xb5,0x19,0x26,0x36,0xa1,0x65,0x2e};
    static int          carry6      = 1;
    mpz_from_bytes(augend, augend6, 4);
    mpz_from_bytes(addend, addend6, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum6, sum_data, 32) != 0 || carry6 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend7[32] = {0xf8,0x4d,0xd5,0x36,0x58,0xa8,0x54,0x26,0x2a,0x21,0x57,0x34,0x8d,0x58,0x58,0xbd,0x89,0x66,0x09,0x63,0xbf,0xa1,0xfc,0xfa,0x8f,0xa2,0x55,0x4c,0x8d,0xaa,0x89,0xce};
    static std::uint8_t addend7[32] = {0xc6,0x4b,0x9d,0x16,0xd3,0x79,0x9d,0xff,0x27,0xb6,0x6c,0x3f,0xa2,0xae,0x07,0xda,0xa3,0x5e,0x46,0xa9,0x35,0x80,0x59,0x79,0xaf,0x05,0x23,0x96,0x5e,0xcf,0x1e,0x1c};
    static std::uint8_t sum7[32]    = {0xbe,0x99,0x72,0x4d,0x2c,0x21,0xf2,0x25,0x51,0xd7,0xc3,0x74,0x30,0x06,0x60,0x98,0x2c,0xc4,0x50,0x0c,0xf5,0x22,0x56,0x74,0x3e,0xa7,0x78,0xe2,0xec,0x79,0xa7,0xea};
    static int          carry7      = 1;
    mpz_from_bytes(augend, augend7, 4);
    mpz_from_bytes(addend, addend7, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum7, sum_data, 32) != 0 || carry7 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend8[32] = {0xb3,0xe5,0xe9,0xe0,0x33,0x5e,0xeb,0x62,0x6e,0x87,0xdd,0x2c,0xea,0x89,0xbc,0xc3,0xcc,0x4d,0x9a,0x7e,0x53,0xa6,0xda,0xeb,0x52,0x8f,0x9a,0x3f,0x2f,0x92,0xae,0x9f};
    static std::uint8_t addend8[32] = {0x21,0x8f,0x88,0xda,0x04,0xe9,0x38,0x1b,0xe0,0x5d,0x97,0x99,0x1f,0xb2,0xaf,0xcc,0xe2,0xf7,0xf0,0x4c,0xbb,0x53,0x63,0x3c,0x65,0x46,0x42,0x10,0x9f,0x42,0x5c,0xf9};
    static std::uint8_t sum8[32]    = {0xd5,0x75,0x72,0xba,0x38,0x48,0x23,0x7e,0x4e,0xe5,0x74,0xc6,0x0a,0x3c,0x6c,0x90,0xaf,0x45,0x8a,0xcb,0x0e,0xfa,0x3e,0x27,0xb7,0xd5,0xdc,0x4f,0xce,0xd5,0x0b,0x98};
    static int          carry8      = 0;
    mpz_from_bytes(augend, augend8, 4);
    mpz_from_bytes(addend, addend8, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum8, sum_data, 32) != 0 || carry8 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend9[32] = {0x82,0xef,0xaf,0x19,0xb2,0xeb,0xb9,0xbc,0x26,0x57,0x40,0xcb,0x96,0x58,0x21,0xe2,0x20,0x12,0x8a,0xa2,0xfe,0xce,0x97,0x95,0x1c,0xc6,0xb9,0x22,0x5a,0xd4,0x84,0x9d};
    static std::uint8_t addend9[32] = {0xd6,0x57,0x44,0x43,0x41,0xe1,0x3f,0xe8,0x58,0x3c,0x17,0x29,0xe7,0x0e,0x04,0x0c,0x6d,0xe7,0xd8,0x97,0x28,0xe4,0x43,0xf7,0x18,0xbc,0x92,0x7d,0x83,0x7e,0xa7,0x1f};
    static std::uint8_t sum9[32]    = {0x59,0x46,0xf3,0x5c,0xf4,0xcc,0xf9,0xa4,0x7e,0x93,0x57,0xf5,0x7d,0x66,0x25,0xee,0x8d,0xfa,0x63,0x3a,0x27,0xb2,0xdb,0x8c,0x35,0x83,0x4b,0x9f,0xde,0x53,0x2b,0xbc};
    static int          carry9      = 1;
    mpz_from_bytes(augend, augend9, 4);
    mpz_from_bytes(addend, addend9, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum9, sum_data, 32) != 0 || carry9 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend10[32] = {0xcb,0xbf,0x9a,0xc1,0x03,0xfe,0xa9,0x9e,0x14,0xb0,0x38,0xcf,0xf9,0x61,0xcb,0xf9,0x93,0xc9,0x17,0x6e,0xc0,0x02,0x2d,0x5f,0x33,0x47,0x77,0x2d,0x30,0xc2,0xe2,0x76};
    static std::uint8_t addend10[32] = {0x48,0x11,0x99,0xef,0x4a,0xaa,0x76,0x1f,0xeb,0x4d,0xff,0xd8,0xe3,0x02,0x1b,0xd9,0xd9,0xad,0xb5,0x65,0x79,0xa4,0xf6,0xd1,0x07,0xc7,0xef,0x89,0xed,0xbf,0x6f,0x2d};
    static std::uint8_t sum10[32]    = {0x13,0xd1,0x34,0xb0,0x4e,0xa9,0x1f,0xbd,0xff,0xfe,0x38,0xa8,0xdc,0x63,0xe7,0xd3,0x6d,0x76,0xcc,0xd4,0x39,0xa7,0x24,0x30,0x3b,0x0f,0x66,0xb7,0x1e,0x82,0x51,0xa3};
    static int          carry10      = 1;
    mpz_from_bytes(augend, augend10, 4);
    mpz_from_bytes(addend, addend10, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum10, sum_data, 32) != 0 || carry10 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend11[32] = {0xe6,0xff,0x7d,0x68,0x35,0xca,0xc5,0x8a,0xf1,0x1f,0x7f,0x84,0xbf,0x98,0xfc,0x2b,0x5f,0x9e,0x0b,0xe2,0xa8,0x6e,0x12,0xb2,0x5f,0x96,0x9e,0xba,0x61,0x18,0xff,0x30};
    static std::uint8_t addend11[32] = {0xad,0xb6,0x2a,0xcf,0xa5,0x6b,0x77,0x92,0x4e,0x99,0xea,0x0a,0x05,0xbc,0xff,0x83,0x34,0xe8,0x51,0x8d,0x02,0x06,0x40,0x7e,0x83,0x07,0x8a,0x5e,0x5f,0xca,0xbd,0x82};
    static std::uint8_t sum11[32]    = {0x94,0xb5,0xa8,0x37,0xdb,0x36,0x3d,0x1d,0x3f,0xb9,0x69,0x8e,0xc5,0x55,0xfb,0xae,0x94,0x86,0x5d,0x6f,0xaa,0x74,0x53,0x30,0xe2,0x9e,0x29,0x18,0xc0,0xe3,0xbc,0xb2};
    static int          carry11      = 1;
    mpz_from_bytes(augend, augend11, 4);
    mpz_from_bytes(addend, addend11, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum11, sum_data, 32) != 0 || carry11 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend12[32] = {0x22,0x97,0x02,0xe4,0xd3,0xa8,0x5b,0x97,0x55,0x56,0x50,0xfd,0xdd,0x9b,0xac,0x00,0x8c,0x26,0xbf,0xbd,0x61,0xd1,0xde,0x35,0x13,0x9a,0xb5,0x62,0x56,0x95,0xee,0xa0};
    static std::uint8_t addend12[32] = {0x61,0xf7,0x56,0x58,0x3a,0xbf,0x99,0xc4,0xda,0xe9,0x59,0x5a,0xcc,0xcd,0xd0,0xf4,0x9f,0x3a,0x66,0x2b,0x96,0xc0,0x52,0x1c,0x86,0xe0,0x6d,0x01,0xa0,0x69,0x50,0x8d};
    static std::uint8_t sum12[32]    = {0x84,0x8e,0x59,0x3d,0x0e,0x67,0xf5,0x5c,0x30,0x3f,0xaa,0x58,0xaa,0x69,0x7c,0xf5,0x2b,0x61,0x25,0xe8,0xf8,0x92,0x30,0x51,0x9a,0x7b,0x22,0x63,0xf6,0xff,0x3f,0x2d};
    static int          carry12      = 0;
    mpz_from_bytes(augend, augend12, 4);
    mpz_from_bytes(addend, addend12, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum12, sum_data, 32) != 0 || carry12 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend13[32] = {0xd7,0x0d,0x6a,0xba,0x81,0x73,0xf2,0x9c,0x25,0x3f,0x8e,0x50,0x06,0xd3,0x87,0xdc,0xa9,0x86,0x52,0x6a,0x44,0x36,0xfa,0xa5,0x1b,0x05,0x9f,0x12,0x8c,0x4d,0x20,0x6a};
    static std::uint8_t addend13[32] = {0x4d,0x52,0x5d,0x26,0x8d,0xd8,0xf3,0x0a,0x91,0xa0,0x06,0x7d,0xb7,0xe9,0xa1,0x0a,0xf8,0x06,0x56,0x31,0x2f,0x04,0x2c,0xb2,0x24,0xa8,0xb8,0x7e,0xc4,0x2f,0x90,0x29};
    static std::uint8_t sum13[32]    = {0x24,0x5f,0xc7,0xe1,0x0f,0x4c,0xe5,0xa6,0xb6,0xdf,0x94,0xcd,0xbe,0xbd,0x28,0xe7,0xa1,0x8c,0xa8,0x9b,0x73,0x3b,0x27,0x57,0x3f,0xae,0x57,0x91,0x50,0x7c,0xb0,0x93};
    static int          carry13      = 1;
    mpz_from_bytes(augend, augend13, 4);
    mpz_from_bytes(addend, addend13, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum13, sum_data, 32) != 0 || carry13 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend14[32] = {0xf0,0x61,0xdf,0x20,0x83,0x07,0xd7,0xa1,0x21,0x0c,0xa9,0x50,0xb2,0x91,0x07,0x05,0xd8,0x09,0xd1,0xb9,0x84,0x6f,0x9f,0xe8,0x89,0xce,0x84,0xdf,0x0a,0x4b,0xd0,0x19};
    static std::uint8_t addend14[32] = {0x71,0x3a,0xf4,0xb3,0x0c,0xb9,0x96,0x72,0x54,0x06,0x22,0xea,0x14,0xb1,0x22,0x4a,0xd4,0x1b,0x46,0x4c,0x10,0xce,0xcf,0x53,0x7d,0xa7,0x6f,0x5b,0xd1,0xcd,0xe0,0x07};
    static std::uint8_t sum14[32]    = {0x61,0x9c,0xd3,0xd3,0x8f,0xc1,0x6e,0x13,0x75,0x12,0xcc,0x3a,0xc7,0x42,0x29,0x50,0xac,0x25,0x18,0x05,0x95,0x3e,0x6f,0x3c,0x07,0x75,0xf4,0x3a,0xdc,0x19,0xb0,0x20};
    static int          carry14      = 1;
    mpz_from_bytes(augend, augend14, 4);
    mpz_from_bytes(addend, addend14, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum14, sum_data, 32) != 0 || carry14 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend15[32] = {0xaf,0x2e,0x09,0x60,0xba,0x48,0x06,0x5d,0xd8,0xc6,0x84,0xc8,0x75,0xa4,0x28,0xc3,0x03,0xc9,0x7c,0x59,0x18,0xec,0x95,0x79,0x00,0xde,0x38,0x5b,0x11,0x29,0x84,0x54};
    static std::uint8_t addend15[32] = {0x4a,0x20,0x5f,0x88,0x19,0xe4,0x34,0x64,0xd5,0x47,0x29,0xba,0xcf,0x5b,0xcf,0x1e,0x26,0x92,0x35,0x6f,0x28,0x86,0x71,0x3c,0xda,0x0e,0xe9,0x12,0x1a,0x0c,0x8e,0xa3};
    static std::uint8_t sum15[32]    = {0xf9,0x4e,0x68,0xe8,0xd4,0x2c,0x3a,0xc2,0xae,0x0d,0xae,0x83,0x44,0xff,0xf7,0xe1,0x2a,0x5b,0xb1,0xc8,0x41,0x73,0x06,0xb5,0xda,0xed,0x21,0x6d,0x2b,0x36,0x12,0xf7};
    static int          carry15      = 0;
    mpz_from_bytes(augend, augend15, 4);
    mpz_from_bytes(addend, addend15, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum15, sum_data, 32) != 0 || carry15 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend16[32] = {0x01,0x7f,0x2b,0x05,0xd2,0x42,0xfe,0x3f,0x4e,0x2d,0x16,0x5a,0x25,0x55,0x87,0x3f,0x02,0x1d,0xc2,0xbc,0x8f,0xf9,0x43,0x3d,0xf7,0x60,0xfc,0x8a,0x30,0xfa,0x5e,0x66};
    static std::uint8_t addend16[32] = {0xdc,0x1d,0x92,0x03,0x2a,0x5c,0x4a,0x52,0xbd,0xe2,0x4d,0xbe,0x86,0x2d,0xec,0xbd,0x35,0xa1,0x56,0x08,0x92,0x14,0x71,0x4a,0xa3,0x43,0xb8,0x0e,0xfd,0x83,0x02,0x68};
    static std::uint8_t sum16[32]    = {0xdd,0x9c,0xbd,0x08,0xfc,0x9f,0x48,0x92,0x0c,0x0f,0x64,0x18,0xab,0x83,0x73,0xfc,0x37,0xbf,0x18,0xc5,0x22,0x0d,0xb4,0x88,0x9a,0xa4,0xb4,0x99,0x2e,0x7d,0x60,0xce};
    static int          carry16      = 0;
    mpz_from_bytes(augend, augend16, 4);
    mpz_from_bytes(addend, addend16, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum16, sum_data, 32) != 0 || carry16 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend17[32] = {0x12,0xd0,0xc8,0x41,0xb3,0xd0,0x63,0x26,0x1c,0x74,0x81,0xc7,0xf8,0xeb,0x5a,0x4a,0x52,0x20,0x54,0x14,0x0c,0x64,0xc9,0x5d,0x2b,0xfa,0xa0,0x77,0x43,0xa3,0x09,0xb3};
    static std::uint8_t addend17[32] = {0xa5,0x8f,0x0e,0x17,0xa0,0x36,0x27,0xb2,0xe4,0x51,0x62,0x8f,0x8e,0xff,0xe3,0x6f,0x46,0x6d,0xc1,0x5f,0x16,0xd5,0x55,0x4c,0xbe,0x2a,0xfa,0x6d,0x12,0xfe,0xef,0xae};
    static std::uint8_t sum17[32]    = {0xb8,0x5f,0xd6,0x59,0x54,0x06,0x8a,0xd9,0x00,0xc5,0xe4,0x57,0x87,0xeb,0x3d,0xb9,0x98,0x8e,0x15,0x73,0x23,0x3a,0x1e,0xa9,0xea,0x25,0x9a,0xe4,0x56,0xa1,0xf9,0x61};
    static int          carry17      = 0;
    mpz_from_bytes(augend, augend17, 4);
    mpz_from_bytes(addend, addend17, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum17, sum_data, 32) != 0 || carry17 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend18[32] = {0x6d,0x55,0xdb,0xc3,0x5f,0xd7,0x79,0xfd,0xf5,0x3f,0x51,0x12,0x40,0x4d,0x4f,0x0a,0x88,0xeb,0x15,0x10,0x33,0x95,0x9b,0x84,0xdc,0x73,0xe0,0x3c,0xd4,0x99,0x81,0xa8};
    static std::uint8_t addend18[32] = {0xf5,0x67,0x2b,0xdc,0xa6,0x1f,0x69,0xb2,0x7f,0x5f,0xc6,0xce,0x46,0x3c,0x38,0xb4,0x0d,0xdd,0x0e,0x29,0x80,0x28,0x59,0x46,0x41,0x14,0x25,0x74,0x73,0x65,0xad,0x84};
    static std::uint8_t sum18[32]    = {0x62,0xbd,0x07,0xa0,0x05,0xf6,0xe3,0xb0,0x74,0x9f,0x17,0xe0,0x86,0x89,0x87,0xbe,0x96,0xc8,0x23,0x39,0xb3,0xbd,0xf4,0xcb,0x1d,0x88,0x05,0xb1,0x47,0xff,0x2f,0x2c};
    static int          carry18      = 1;
    mpz_from_bytes(augend, augend18, 4);
    mpz_from_bytes(addend, addend18, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum18, sum_data, 32) != 0 || carry18 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend19[32] = {0x50,0x73,0x34,0x55,0x75,0x58,0x35,0xd4,0xa7,0xca,0x08,0xc3,0xa8,0x7c,0xc8,0x13,0x3b,0xf9,0x83,0x1a,0x56,0x23,0x5d,0x11,0xe9,0xf8,0xbd,0x44,0x6f,0x02,0x54,0x87};
    static std::uint8_t addend19[32] = {0xcf,0x44,0xb5,0x45,0xc8,0xa6,0xee,0xfe,0x28,0xc1,0xb7,0x2b,0x51,0xeb,0x81,0x23,0x91,0xe1,0x89,0x5f,0x5b,0x2c,0x3d,0x40,0x74,0x46,0xa1,0x61,0xfb,0xf8,0x0e,0x27};
    static std::uint8_t sum19[32]    = {0x1f,0xb7,0xe9,0x9b,0x3d,0xff,0x24,0xd2,0xd0,0x8b,0xbf,0xee,0xfa,0x68,0x49,0x36,0xcd,0xdb,0x0c,0x79,0xb1,0x4f,0x9a,0x52,0x5e,0x3f,0x5e,0xa6,0x6a,0xfa,0x62,0xae};
    static int          carry19      = 1;
    mpz_from_bytes(augend, augend19, 4);
    mpz_from_bytes(addend, addend19, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum19, sum_data, 32) != 0 || carry19 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend20[32] = {0xfb,0x89,0x5a,0x79,0x20,0x1c,0x75,0x0a,0x1a,0xef,0xde,0xb4,0x1b,0x53,0x3f,0x24,0xb8,0x12,0x81,0x10,0x2a,0x2a,0xce,0x48,0x45,0x1f,0x65,0x1f,0xa3,0x8f,0x9c,0xd0};
    static std::uint8_t addend20[32] = {0xc2,0xb8,0x98,0x45,0x9b,0x13,0x29,0xca,0x16,0xec,0x62,0x81,0xa2,0x34,0xd1,0xcf,0xcc,0xcd,0x91,0x5b,0x0d,0x85,0x00,0xf2,0x7e,0x30,0x17,0xe4,0x97,0x95,0xf2,0xad};
    static std::uint8_t sum20[32]    = {0xbe,0x41,0xf2,0xbe,0xbb,0x2f,0x9e,0xd4,0x31,0xdc,0x41,0x35,0xbd,0x88,0x10,0xf4,0x84,0xe0,0x12,0x6b,0x37,0xaf,0xcf,0x3a,0xc3,0x4f,0x7d,0x04,0x3b,0x25,0x8f,0x7d};
    static int          carry20      = 1;
    mpz_from_bytes(augend, augend20, 4);
    mpz_from_bytes(addend, addend20, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum20, sum_data, 32) != 0 || carry20 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend21[32] = {0x7d,0x70,0x37,0x9c,0xd4,0x6e,0xee,0x10,0x3e,0xad,0xcb,0xd9,0x7b,0x17,0x1a,0x48,0x5a,0x89,0x3d,0x29,0xa3,0x38,0x88,0xb6,0xc0,0xc7,0xe2,0xcd,0x33,0x20,0x1f,0xbc};
    static std::uint8_t addend21[32] = {0x03,0xb3,0x89,0x43,0xc3,0x76,0x6a,0xc3,0xf5,0x54,0x53,0xa1,0x44,0x12,0xec,0xe6,0xaa,0xc0,0x3f,0xfe,0x08,0xe6,0xb5,0xb8,0x23,0x7e,0x6c,0x25,0x44,0x5e,0x90,0x6b};
    static std::uint8_t sum21[32]    = {0x81,0x23,0xc0,0xe0,0x97,0xe5,0x58,0xd4,0x34,0x02,0x1f,0x7a,0xbf,0x2a,0x07,0x2f,0x05,0x49,0x7d,0x27,0xac,0x1f,0x3e,0x6e,0xe4,0x46,0x4e,0xf2,0x77,0x7e,0xb0,0x27};
    static int          carry21      = 0;
    mpz_from_bytes(augend, augend21, 4);
    mpz_from_bytes(addend, addend21, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum21, sum_data, 32) != 0 || carry21 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend22[32] = {0x5d,0x7d,0x5d,0x3f,0x13,0x2c,0xcd,0x28,0x13,0xfa,0x80,0x89,0x7a,0x74,0xc5,0xc5,0x65,0xc0,0x15,0x0b,0x23,0xd4,0x69,0x0c,0x06,0xf0,0xba,0xbe,0xdb,0xda,0xc7,0x9a};
    static std::uint8_t addend22[32] = {0x5a,0xe1,0x67,0x93,0x01,0x20,0x8b,0x49,0xb7,0x20,0x31,0xb1,0x0f,0x5a,0x15,0xa3,0xf2,0xbd,0xca,0x31,0x36,0x53,0x97,0xf8,0xcc,0xd8,0x98,0x98,0xab,0xc7,0xf2,0x90};
    static std::uint8_t sum22[32]    = {0xb8,0x5e,0xc4,0xd2,0x14,0x4d,0x58,0x71,0xcb,0x1a,0xb2,0x3a,0x89,0xce,0xdb,0x69,0x58,0x7d,0xdf,0x3c,0x5a,0x28,0x01,0x04,0xd3,0xc9,0x53,0x57,0x87,0xa2,0xba,0x2a};
    static int          carry22      = 0;
    mpz_from_bytes(augend, augend22, 4);
    mpz_from_bytes(addend, addend22, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum22, sum_data, 32) != 0 || carry22 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend23[32] = {0x3e,0x16,0x8a,0xe8,0xf0,0x6d,0x81,0xc4,0xc6,0xa8,0x0b,0x49,0x2e,0x5e,0xed,0x8b,0x86,0x9c,0xd6,0xfa,0x0b,0xd3,0xcf,0x84,0xaf,0x3b,0x41,0xb6,0xa9,0xdd,0xbc,0xc2};
    static std::uint8_t addend23[32] = {0x97,0x54,0x31,0x5b,0xea,0x1b,0x8b,0x33,0x40,0xe3,0xe3,0x04,0x6d,0xe1,0xa3,0x6a,0x6e,0x10,0x22,0xac,0x15,0x99,0x3d,0x01,0x71,0x51,0x8d,0x9f,0x36,0x7d,0xa8,0x1f};
    static std::uint8_t sum23[32]    = {0xd5,0x6a,0xbc,0x44,0xda,0x89,0x0c,0xf8,0x07,0x8b,0xee,0x4d,0x9c,0x40,0x90,0xf5,0xf4,0xac,0xf9,0xa6,0x21,0x6d,0x0c,0x86,0x20,0x8c,0xcf,0x55,0xe0,0x5b,0x64,0xe1};
    static int          carry23      = 0;
    mpz_from_bytes(augend, augend23, 4);
    mpz_from_bytes(addend, addend23, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum23, sum_data, 32) != 0 || carry23 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend24[32] = {0x07,0x97,0x7e,0x71,0xf1,0x32,0xf5,0x4f,0xfb,0x23,0x88,0xaa,0x86,0xa5,0x13,0xb4,0xdb,0x6b,0xc4,0x62,0xf2,0xec,0xf1,0xaa,0x0b,0x04,0xa6,0xd2,0x8b,0x7f,0x62,0xe7};
    static std::uint8_t addend24[32] = {0x6d,0xf1,0x5e,0x74,0x59,0xa3,0xf2,0x9a,0x27,0x3b,0x5a,0x1d,0xe5,0x8e,0xc1,0xfd,0x23,0x53,0x18,0x66,0x43,0xe7,0xda,0xac,0x17,0x17,0xd6,0x85,0x0f,0xea,0x9f,0x50};
    static std::uint8_t sum24[32]    = {0x75,0x88,0xdc,0xe6,0x4a,0xd6,0xe7,0xea,0x22,0x5e,0xe2,0xc8,0x6c,0x33,0xd5,0xb1,0xfe,0xbe,0xdc,0xc9,0x36,0xd4,0xcc,0x56,0x22,0x1c,0x7d,0x57,0x9b,0x6a,0x02,0x37};
    static int          carry24      = 0;
    mpz_from_bytes(augend, augend24, 4);
    mpz_from_bytes(addend, addend24, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum24, sum_data, 32) != 0 || carry24 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend25[32] = {0x04,0xdf,0xda,0x16,0x16,0x2d,0xa7,0x0c,0xaf,0x6e,0x76,0xc0,0x29,0x0c,0x38,0xa0,0xe4,0x8b,0xf5,0xb7,0x51,0x14,0x85,0x75,0xb5,0x7d,0x10,0x56,0xd9,0xd2,0xab,0x84};
    static std::uint8_t addend25[32] = {0xb3,0xd7,0xe1,0xab,0x11,0x04,0x42,0xb8,0x24,0x12,0xae,0x54,0xd2,0xff,0xc8,0xa8,0x05,0xd1,0x34,0xe8,0xcd,0xa6,0xe4,0x30,0x8e,0xcd,0x9f,0x3a,0xa2,0x52,0x2b,0x3f};
    static std::uint8_t sum25[32]    = {0xb8,0xb7,0xbb,0xc1,0x27,0x31,0xe9,0xc4,0xd3,0x81,0x25,0x14,0xfc,0x0c,0x01,0x48,0xea,0x5d,0x2a,0xa0,0x1e,0xbb,0x69,0xa6,0x44,0x4a,0xaf,0x91,0x7c,0x24,0xd6,0xc3};
    static int          carry25      = 0;
    mpz_from_bytes(augend, augend25, 4);
    mpz_from_bytes(addend, addend25, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum25, sum_data, 32) != 0 || carry25 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend26[32] = {0x3c,0x78,0xeb,0x82,0xa9,0x29,0x81,0x32,0x95,0xb1,0x2d,0x7b,0xe3,0x9a,0xc3,0x24,0xcc,0x19,0xdf,0xd1,0xc7,0x51,0x0f,0x22,0xdd,0xd1,0x99,0x3d,0xe1,0x51,0x66,0xda};
    static std::uint8_t addend26[32] = {0x3b,0xcf,0x64,0xd4,0xf9,0xc2,0xc1,0x75,0xa7,0x48,0xce,0x2b,0xca,0xae,0x9e,0x52,0xab,0x34,0xb3,0xec,0x21,0xef,0x50,0x35,0xb9,0x90,0x5a,0x10,0x70,0xcf,0xa0,0x3c};
    static std::uint8_t sum26[32]    = {0x78,0x48,0x50,0x57,0xa2,0xec,0x42,0xa8,0x3c,0xf9,0xfb,0xa7,0xae,0x49,0x61,0x77,0x77,0x4e,0x93,0xbd,0xe9,0x40,0x5f,0x58,0x97,0x61,0xf3,0x4e,0x52,0x21,0x07,0x16};
    static int          carry26      = 0;
    mpz_from_bytes(augend, augend26, 4);
    mpz_from_bytes(addend, addend26, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum26, sum_data, 32) != 0 || carry26 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend27[32] = {0x2e,0x4f,0x77,0x0c,0x15,0xd0,0x3f,0x19,0x91,0xd8,0x59,0xa8,0xa1,0x2d,0x9e,0x1b,0x8a,0x02,0x22,0x07,0xd5,0x03,0xa1,0xec,0x5c,0xa8,0xd7,0x4d,0x88,0xbe,0x42,0x26};
    static std::uint8_t addend27[32] = {0x60,0x10,0x56,0xc4,0x5e,0x28,0x30,0x09,0x09,0x5c,0x60,0xe3,0x81,0x44,0x1e,0xa1,0x17,0x44,0x7a,0x12,0xd0,0xde,0x47,0x95,0xe9,0xdf,0x33,0x3d,0x7e,0xe9,0x76,0x68};
    static std::uint8_t sum27[32]    = {0x8e,0x5f,0xcd,0xd0,0x73,0xf8,0x6f,0x22,0x9b,0x34,0xba,0x8c,0x22,0x71,0xbc,0xbc,0xa1,0x46,0x9c,0x1a,0xa5,0xe1,0xe9,0x82,0x46,0x88,0x0a,0x8b,0x07,0xa7,0xb8,0x8e};
    static int          carry27      = 0;
    mpz_from_bytes(augend, augend27, 4);
    mpz_from_bytes(addend, addend27, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum27, sum_data, 32) != 0 || carry27 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend28[32] = {0xe1,0x29,0x8e,0xe7,0x63,0x67,0x76,0x41,0x00,0x09,0x48,0x76,0xc6,0x93,0x71,0x47,0x91,0xb5,0xa3,0x62,0x13,0x26,0x78,0xc5,0xac,0x14,0xd5,0x32,0x7d,0xca,0xb7,0xf5};
    static std::uint8_t addend28[32] = {0x73,0x92,0x0f,0x25,0x63,0x25,0x44,0xea,0x96,0x3a,0x5d,0xff,0x29,0xa8,0x16,0x89,0xd9,0xff,0xf2,0xad,0x4b,0x32,0xee,0x29,0x07,0x5c,0xec,0x96,0x72,0x5a,0x97,0x97};
    static std::uint8_t sum28[32]    = {0x54,0xbb,0x9e,0x0c,0xc6,0x8c,0xbb,0x2b,0x96,0x43,0xa6,0x75,0xf0,0x3b,0x87,0xd1,0x6b,0xb5,0x96,0x0f,0x5e,0x59,0x66,0xee,0xb3,0x71,0xc1,0xc8,0xf0,0x25,0x4f,0x8c};
    static int          carry28      = 1;
    mpz_from_bytes(augend, augend28, 4);
    mpz_from_bytes(addend, addend28, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum28, sum_data, 32) != 0 || carry28 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend29[32] = {0xed,0x7e,0x27,0x5e,0x4a,0x9f,0x99,0x27,0xfd,0xb6,0x82,0x28,0xd5,0xc7,0xd8,0x51,0x3f,0x8f,0xb6,0x90,0x74,0xd6,0x0a,0x86,0xbc,0x75,0x79,0x88,0x8d,0xc5,0x16,0x65};
    static std::uint8_t addend29[32] = {0xc7,0x4e,0x58,0xd5,0x13,0x46,0x4f,0xb2,0x2b,0xa9,0xf0,0x7f,0xb7,0xaf,0x37,0xe2,0x00,0x86,0x01,0x92,0x86,0x64,0x16,0x1c,0x89,0xf8,0x9a,0x37,0x46,0x4f,0x21,0xeb};
    static std::uint8_t sum29[32]    = {0xb4,0xcc,0x80,0x33,0x5d,0xe5,0xe8,0xda,0x29,0x60,0x72,0xa8,0x8d,0x77,0x10,0x33,0x40,0x15,0xb8,0x22,0xfb,0x3a,0x20,0xa3,0x46,0x6e,0x13,0xbf,0xd4,0x14,0x38,0x50};
    static int          carry29      = 1;
    mpz_from_bytes(augend, augend29, 4);
    mpz_from_bytes(addend, addend29, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum29, sum_data, 32) != 0 || carry29 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend30[32] = {0x6b,0x9e,0x5e,0xc4,0x54,0xd7,0x54,0x95,0xee,0xec,0x5d,0xfe,0x96,0x5e,0x9e,0x4b,0x52,0x3b,0x35,0xf3,0x85,0x2b,0x75,0xb9,0x78,0xff,0xdf,0xce,0x14,0x97,0x7d,0x18};
    static std::uint8_t addend30[32] = {0x24,0x87,0xd1,0x19,0xe6,0xb9,0xee,0xd7,0x60,0x21,0x74,0x53,0xf9,0xc5,0x14,0xc6,0x3a,0x14,0xc0,0x16,0x6d,0xc8,0x14,0xfc,0xa3,0x7e,0x55,0xfd,0x2b,0x34,0x70,0x78};
    static std::uint8_t sum30[32]    = {0x90,0x26,0x2f,0xde,0x3b,0x91,0x43,0x6d,0x4f,0x0d,0xd2,0x52,0x90,0x23,0xb3,0x11,0x8c,0x4f,0xf6,0x09,0xf2,0xf3,0x8a,0xb6,0x1c,0x7e,0x35,0xcb,0x3f,0xcb,0xed,0x90};
    static int          carry30      = 0;
    mpz_from_bytes(augend, augend30, 4);
    mpz_from_bytes(addend, addend30, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum30, sum_data, 32) != 0 || carry30 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend31[32] = {0xb5,0x6a,0xb6,0x18,0xd9,0x2b,0x80,0xbc,0x2d,0x19,0x9e,0xf1,0xc6,0xa8,0x20,0xb0,0xd2,0x4f,0xff,0xc2,0xe8,0x6b,0x23,0xd8,0x00,0x08,0xc0,0x49,0x67,0xe9,0x45,0x62};
    static std::uint8_t addend31[32] = {0x45,0x4e,0x71,0x17,0x13,0xde,0xdb,0x3c,0x4c,0xc9,0xd6,0xd4,0xdd,0x4f,0x74,0x5b,0x21,0xca,0x8c,0x0e,0xef,0xe7,0xf8,0xda,0xb6,0x99,0x37,0xdf,0xac,0xc4,0xc0,0xa3};
    static std::uint8_t sum31[32]    = {0xfa,0xb9,0x27,0x2f,0xed,0x0a,0x5b,0xf8,0x79,0xe3,0x75,0xc6,0xa3,0xf7,0x95,0x0b,0xf4,0x1a,0x8b,0xd1,0xd8,0x53,0x1c,0xb2,0xb6,0xa1,0xf8,0x29,0x14,0xae,0x06,0x05};
    static int          carry31      = 0;
    mpz_from_bytes(augend, augend31, 4);
    mpz_from_bytes(addend, addend31, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum31, sum_data, 32) != 0 || carry31 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend32[32] = {0x86,0xd3,0x9c,0x5d,0xf9,0x57,0xb7,0x28,0xe2,0xf5,0x74,0x93,0x3b,0xef,0x8b,0x74,0xd9,0x8b,0xa0,0xf7,0x29,0x19,0xb0,0x66,0x40,0xbd,0xd4,0x48,0x59,0x0e,0x78,0x02};
    static std::uint8_t addend32[32] = {0xd3,0xcb,0x3a,0x5a,0x95,0xc1,0x00,0x3d,0x03,0x6d,0xda,0x58,0x59,0x83,0x2e,0xae,0x35,0x24,0x22,0xbe,0x7d,0x2f,0x80,0xb8,0x93,0xcd,0xbd,0x75,0x36,0x39,0x2d,0x5a};
    static std::uint8_t sum32[32]    = {0x5a,0x9e,0xd6,0xb8,0x8f,0x18,0xb7,0x65,0xe6,0x63,0x4e,0xeb,0x95,0x72,0xba,0x23,0x0e,0xaf,0xc3,0xb5,0xa6,0x49,0x31,0x1e,0xd4,0x8b,0x91,0xbd,0x8f,0x47,0xa5,0x5c};
    static int          carry32      = 1;
    mpz_from_bytes(augend, augend32, 4);
    mpz_from_bytes(addend, addend32, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum32, sum_data, 32) != 0 || carry32 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend33[32] = {0xd0,0x6e,0x18,0x4b,0xd6,0xa0,0x20,0x76,0xca,0x8c,0x46,0xf3,0x85,0x6b,0x00,0xe5,0x66,0x1f,0x49,0x12,0x34,0x81,0xe5,0xf4,0x95,0xa8,0xd1,0xbd,0x98,0xc8,0xf7,0x93};
    static std::uint8_t addend33[32] = {0x3c,0x77,0xa5,0x0e,0x32,0xad,0x97,0x2a,0x60,0x7b,0x6e,0x70,0x12,0x0d,0x1a,0x04,0xcc,0x37,0x72,0xba,0x9d,0xab,0x6b,0xaa,0x8e,0x05,0x60,0xf8,0x78,0x14,0xd7,0xd0};
    static std::uint8_t sum33[32]    = {0x0c,0xe5,0xbd,0x5a,0x09,0x4d,0xb7,0xa1,0x2b,0x07,0xb5,0x63,0x97,0x78,0x1a,0xea,0x32,0x56,0xbb,0xcc,0xd2,0x2d,0x51,0x9f,0x23,0xae,0x32,0xb6,0x10,0xdd,0xcf,0x63};
    static int          carry33      = 1;
    mpz_from_bytes(augend, augend33, 4);
    mpz_from_bytes(addend, addend33, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum33, sum_data, 32) != 0 || carry33 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend34[32] = {0x12,0xa9,0xd6,0x4d,0x32,0x47,0xee,0x11,0x84,0xa9,0x9d,0xe5,0xc6,0x98,0xcc,0x2b,0x83,0x59,0xa7,0x2f,0xf5,0x24,0xde,0x36,0x39,0x85,0x43,0xb5,0x9f,0x4e,0xa6,0xb3};
    static std::uint8_t addend34[32] = {0xd0,0xbd,0x73,0xb1,0xce,0x12,0x28,0xdb,0x9c,0x85,0x19,0x40,0xfe,0x14,0x55,0xd0,0x42,0xb4,0x31,0x7f,0xe3,0xb6,0x9b,0x96,0xf9,0xb5,0x8e,0x5b,0x50,0x61,0x60,0xf0};
    static std::uint8_t sum34[32]    = {0xe3,0x67,0x49,0xff,0x00,0x5a,0x16,0xed,0x21,0x2e,0xb7,0x26,0xc4,0xad,0x21,0xfb,0xc6,0x0d,0xd8,0xaf,0xd8,0xdb,0x79,0xcd,0x33,0x3a,0xd2,0x10,0xef,0xb0,0x07,0xa3};
    static int          carry34      = 0;
    mpz_from_bytes(augend, augend34, 4);
    mpz_from_bytes(addend, addend34, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum34, sum_data, 32) != 0 || carry34 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend35[32] = {0x72,0x65,0x23,0xf7,0x4a,0x8d,0xaf,0x99,0x04,0x5a,0x8c,0x38,0xa8,0x3d,0x7d,0xd5,0xf7,0xb0,0x47,0x3e,0x18,0xa4,0xdc,0xf7,0x39,0x82,0x96,0x4f,0x4b,0x06,0xa6,0xa2};
    static std::uint8_t addend35[32] = {0x7a,0xd8,0xd2,0x3c,0x41,0x32,0xac,0x39,0xc5,0x00,0xbc,0x91,0x5c,0x62,0x2b,0xad,0xce,0x98,0x78,0x4b,0x38,0x55,0xdd,0x85,0xe8,0x39,0xba,0x09,0xd7,0x86,0xf4,0x8c};
    static std::uint8_t sum35[32]    = {0xed,0x3d,0xf6,0x33,0x8b,0xc0,0x5b,0xd2,0xc9,0x5b,0x48,0xca,0x04,0x9f,0xa9,0x83,0xc6,0x48,0xbf,0x89,0x50,0xfa,0xba,0x7d,0x21,0xbc,0x50,0x59,0x22,0x8d,0x9b,0x2e};
    static int          carry35      = 0;
    mpz_from_bytes(augend, augend35, 4);
    mpz_from_bytes(addend, addend35, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum35, sum_data, 32) != 0 || carry35 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend36[32] = {0x87,0x6c,0xd3,0x0f,0xec,0x49,0xcd,0x4b,0x71,0x27,0xe0,0xee,0x3c,0xda,0x57,0xb7,0x06,0x9f,0xbb,0x31,0x49,0x47,0xb8,0x7e,0x0c,0x5c,0x0f,0x3a,0x06,0xe5,0x75,0x6d};
    static std::uint8_t addend36[32] = {0x3f,0xd1,0x65,0x14,0xcb,0x9a,0x8f,0xf3,0x1b,0x10,0xb1,0xe2,0x49,0xed,0xe9,0x96,0xda,0x14,0x8b,0xfa,0x8b,0xb6,0xd7,0x1a,0xc5,0x6d,0x02,0xd6,0x2b,0x93,0xc3,0xcb};
    static std::uint8_t sum36[32]    = {0xc7,0x3e,0x38,0x24,0xb7,0xe4,0x5d,0x3e,0x8c,0x38,0x92,0xd0,0x86,0xc8,0x41,0x4d,0xe0,0xb4,0x47,0x2b,0xd4,0xfe,0x8f,0x98,0xd1,0xc9,0x12,0x10,0x32,0x79,0x39,0x38};
    static int          carry36      = 0;
    mpz_from_bytes(augend, augend36, 4);
    mpz_from_bytes(addend, addend36, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum36, sum_data, 32) != 0 || carry36 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend37[32] = {0x7e,0x13,0xa5,0x77,0x30,0x05,0xf9,0x03,0x57,0xe1,0xc3,0xff,0x42,0xd3,0x6a,0xd2,0xcc,0x2d,0xaf,0x49,0x46,0x4a,0x83,0x42,0x37,0x78,0xbe,0x0f,0xc5,0x03,0xc6,0xaa};
    static std::uint8_t addend37[32] = {0x59,0xfa,0x6e,0x4e,0x81,0xcf,0x53,0x2e,0x9f,0x73,0xbb,0x8c,0xea,0xc3,0x8d,0x96,0x79,0x8d,0x21,0xa4,0x60,0x22,0x27,0xfc,0xdc,0x4e,0x73,0xb9,0xd5,0xf6,0x2c,0x68};
    static std::uint8_t sum37[32]    = {0xd8,0x0e,0x13,0xc5,0xb1,0xd5,0x4c,0x31,0xf7,0x55,0x7f,0x8c,0x2d,0x96,0xf8,0x69,0x45,0xba,0xd0,0xed,0xa6,0x6c,0xab,0x3f,0x13,0xc7,0x31,0xc9,0x9a,0xf9,0xf3,0x12};
    static int          carry37      = 0;
    mpz_from_bytes(augend, augend37, 4);
    mpz_from_bytes(addend, addend37, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum37, sum_data, 32) != 0 || carry37 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend38[32] = {0xcd,0xa6,0x80,0x8e,0x8f,0x7b,0x3a,0xdc,0x9d,0x5f,0x42,0x3b,0x7d,0x6f,0x19,0x90,0x17,0x39,0x6e,0x67,0x45,0x3c,0xee,0xfb,0x0a,0x6d,0x65,0x9f,0x95,0x33,0x36,0xed};
    static std::uint8_t addend38[32] = {0x29,0xce,0x8b,0xd2,0x14,0x01,0x08,0x03,0x44,0x89,0xa9,0x5c,0xd0,0x62,0xc1,0xa3,0x4b,0x5f,0xb8,0x09,0x57,0xa3,0xf1,0xd9,0x66,0xdd,0xc8,0x4f,0xbf,0xdb,0xa3,0x0d};
    static std::uint8_t sum38[32]    = {0xf7,0x75,0x0c,0x60,0xa3,0x7c,0x42,0xdf,0xe1,0xe8,0xeb,0x98,0x4d,0xd1,0xdb,0x33,0x62,0x99,0x26,0x70,0x9c,0xe0,0xe0,0xd4,0x71,0x4b,0x2d,0xef,0x55,0x0e,0xd9,0xfa};
    static int          carry38      = 0;
    mpz_from_bytes(augend, augend38, 4);
    mpz_from_bytes(addend, addend38, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum38, sum_data, 32) != 0 || carry38 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend39[32] = {0x8f,0x8c,0x13,0x15,0x1b,0x7f,0x26,0x1f,0xd3,0xfb,0xc8,0xd0,0xfa,0x21,0xf1,0xed,0x39,0xba,0x10,0x5d,0x13,0x44,0x3c,0xf3,0xeb,0x44,0x2c,0xcc,0xb4,0xe0,0x65,0xbc};
    static std::uint8_t addend39[32] = {0xa9,0x0a,0xfc,0x0a,0xb5,0xf1,0x85,0xee,0xd3,0x2f,0xd7,0xcb,0x43,0x0e,0xf9,0x86,0x11,0xf4,0x98,0x68,0xff,0x96,0xfb,0xba,0x36,0x2e,0xa6,0x3e,0x3b,0x7a,0x13,0x53};
    static std::uint8_t sum39[32]    = {0x38,0x97,0x0f,0x1f,0xd1,0x70,0xac,0x0e,0xa7,0x2b,0xa0,0x9c,0x3d,0x30,0xeb,0x73,0x4b,0xae,0xa8,0xc6,0x12,0xdb,0x38,0xae,0x21,0x72,0xd3,0x0a,0xf0,0x5a,0x79,0x0f};
    static int          carry39      = 1;
    mpz_from_bytes(augend, augend39, 4);
    mpz_from_bytes(addend, addend39, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum39, sum_data, 32) != 0 || carry39 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend40[32] = {0xfd,0x32,0x76,0x21,0x49,0x2f,0x5a,0x5a,0xac,0x36,0x9f,0x4f,0x15,0x2b,0x63,0xec,0x63,0x9f,0x1f,0xb3,0xad,0x8f,0x75,0xbb,0x55,0x04,0x7b,0xe1,0xe4,0xd6,0xa3,0xe8};
    static std::uint8_t addend40[32] = {0x24,0x51,0x81,0xc3,0x7f,0x27,0x82,0x48,0xe5,0x8e,0x78,0x98,0x4f,0x13,0x13,0x38,0xb0,0xe3,0xbb,0x3f,0x0f,0x81,0x9e,0x8f,0x5d,0xf5,0x99,0x36,0x80,0xad,0x2a,0x97};
    static std::uint8_t sum40[32]    = {0x21,0x83,0xf7,0xe4,0xc8,0x56,0xdc,0xa3,0x91,0xc5,0x17,0xe7,0x64,0x3e,0x77,0x25,0x14,0x82,0xda,0xf2,0xbd,0x11,0x14,0x4a,0xb2,0xfa,0x15,0x18,0x65,0x83,0xce,0x7f};
    static int          carry40      = 1;
    mpz_from_bytes(augend, augend40, 4);
    mpz_from_bytes(addend, addend40, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum40, sum_data, 32) != 0 || carry40 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend41[32] = {0xd3,0xa1,0xf7,0xdc,0x12,0x94,0xc0,0x84,0x93,0x78,0x4c,0x93,0xee,0x65,0x61,0x13,0x85,0x9f,0x71,0xb2,0xaf,0x85,0x5e,0x7e,0x88,0xd2,0x14,0x7c,0xf0,0xb0,0x09,0x2e};
    static std::uint8_t addend41[32] = {0x0f,0x03,0x5d,0xa2,0x67,0x78,0x2f,0x04,0xe9,0x06,0x47,0x2b,0x52,0xdd,0x53,0x1f,0x77,0xaa,0x13,0x98,0x9e,0xdd,0xe8,0x2d,0x85,0xbe,0x74,0x40,0x30,0x05,0x63,0xd6};
    static std::uint8_t sum41[32]    = {0xe2,0xa5,0x55,0x7e,0x7a,0x0c,0xef,0x89,0x7c,0x7e,0x93,0xbf,0x41,0x42,0xb4,0x32,0xfd,0x49,0x85,0x4b,0x4e,0x63,0x46,0xac,0x0e,0x90,0x88,0xbd,0x20,0xb5,0x6d,0x04};
    static int          carry41      = 0;
    mpz_from_bytes(augend, augend41, 4);
    mpz_from_bytes(addend, addend41, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum41, sum_data, 32) != 0 || carry41 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend42[32] = {0x0a,0xfb,0x5f,0x68,0x09,0x38,0xf6,0xd3,0xf8,0x44,0x9f,0x64,0xb0,0xfb,0x4c,0x58,0xc6,0x16,0xd5,0xdf,0xa4,0x7a,0x8e,0x2e,0xa5,0x57,0x61,0xd5,0xfd,0x39,0x63,0xad};
    static std::uint8_t addend42[32] = {0x49,0x84,0x75,0xd8,0x19,0xb9,0x0a,0xed,0x55,0x96,0xb8,0x7b,0xea,0x30,0x96,0xa7,0xce,0xbc,0x29,0xe7,0x99,0x3a,0x9f,0x7b,0xc8,0x3a,0xdb,0x98,0x3e,0x24,0xc6,0x78};
    static std::uint8_t sum42[32]    = {0x54,0x7f,0xd5,0x40,0x22,0xf2,0x01,0xc1,0x4d,0xdb,0x57,0xe0,0x9b,0x2b,0xe3,0x00,0x94,0xd2,0xff,0xc7,0x3d,0xb5,0x2d,0xaa,0x6d,0x92,0x3d,0x6e,0x3b,0x5e,0x2a,0x25};
    static int          carry42      = 0;
    mpz_from_bytes(augend, augend42, 4);
    mpz_from_bytes(addend, addend42, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum42, sum_data, 32) != 0 || carry42 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend43[32] = {0x8c,0x56,0x1c,0x03,0xcd,0x0a,0x02,0xc4,0x36,0xa6,0x62,0x63,0xee,0x80,0x46,0x0e,0xf8,0x3d,0x91,0xa2,0xff,0x51,0x32,0x55,0xc7,0x23,0xf6,0x2a,0xf7,0x08,0x4a,0x40};
    static std::uint8_t addend43[32] = {0x48,0xe5,0x56,0xf3,0xd0,0x72,0x8a,0x01,0xad,0x25,0xe2,0x4e,0x44,0x13,0x42,0x02,0x9f,0x3e,0x2e,0x43,0x43,0xe8,0xdc,0x32,0x70,0x63,0xee,0x0e,0xac,0x08,0x03,0x1c};
    static std::uint8_t sum43[32]    = {0xd5,0x3b,0x72,0xf7,0x9d,0x7c,0x8c,0xc5,0xe3,0xcc,0x44,0xb2,0x32,0x93,0x88,0x11,0x97,0x7b,0xbf,0xe6,0x43,0x3a,0x0e,0x88,0x37,0x87,0xe4,0x39,0xa3,0x10,0x4d,0x5c};
    static int          carry43      = 0;
    mpz_from_bytes(augend, augend43, 4);
    mpz_from_bytes(addend, addend43, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum43, sum_data, 32) != 0 || carry43 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend44[32] = {0x8c,0x32,0x80,0x21,0xd1,0x9b,0x82,0xe0,0x05,0x38,0x19,0x16,0xe6,0xf8,0x13,0x44,0x42,0x6a,0xee,0xbb,0x4f,0x49,0x6f,0x0d,0x7a,0xb6,0x7d,0x30,0x03,0xa0,0x28,0x41};
    static std::uint8_t addend44[32] = {0x90,0xb6,0x20,0x96,0x71,0x8b,0x6a,0x3b,0xff,0xfe,0x56,0x09,0x61,0x20,0x56,0x86,0xf3,0x5b,0x4c,0xa1,0x67,0x91,0x7c,0x77,0x42,0x15,0x26,0x9f,0x92,0x8b,0x76,0xbe};
    static std::uint8_t sum44[32]    = {0x1c,0xe8,0xa0,0xb8,0x43,0x26,0xed,0x1c,0x05,0x36,0x6f,0x20,0x48,0x18,0x69,0xcb,0x35,0xc6,0x3b,0x5c,0xb6,0xda,0xeb,0x84,0xbc,0xcb,0xa3,0xcf,0x96,0x2b,0x9e,0xff};
    static int          carry44      = 1;
    mpz_from_bytes(augend, augend44, 4);
    mpz_from_bytes(addend, addend44, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum44, sum_data, 32) != 0 || carry44 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend45[32] = {0x6f,0xb8,0xe9,0x25,0x04,0x8b,0x9b,0x4f,0xa2,0x7f,0x6a,0x4a,0x56,0xd1,0x1b,0x1f,0x21,0x46,0x09,0x09,0x3e,0x44,0x14,0x5f,0x6a,0x93,0xe4,0xb7,0xc1,0x7e,0x38,0x37};
    static std::uint8_t addend45[32] = {0xc5,0x23,0x4f,0x6e,0xc9,0x03,0x95,0xe8,0x90,0x83,0x19,0x93,0xae,0xa9,0x08,0x2f,0x38,0x7b,0x10,0x6e,0x57,0x8d,0xc9,0x6d,0x1e,0xed,0x2e,0x60,0xf3,0xde,0x7f,0x9a};
    static std::uint8_t sum45[32]    = {0x34,0xdc,0x38,0x93,0xcd,0x8f,0x31,0x38,0x33,0x02,0x83,0xde,0x05,0x7a,0x23,0x4e,0x59,0xc1,0x19,0x77,0x95,0xd1,0xdd,0xcc,0x89,0x81,0x13,0x18,0xb5,0x5c,0xb7,0xd1};
    static int          carry45      = 1;
    mpz_from_bytes(augend, augend45, 4);
    mpz_from_bytes(addend, addend45, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum45, sum_data, 32) != 0 || carry45 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend46[32] = {0xb1,0x89,0xe7,0x43,0xb6,0xf7,0x0e,0x63,0x94,0x43,0x09,0x78,0x91,0x40,0xe1,0x57,0x39,0xd8,0xe9,0xaa,0x13,0x3a,0xc8,0x8e,0x4b,0x77,0x41,0x33,0x50,0x20,0xd5,0x20};
    static std::uint8_t addend46[32] = {0xc9,0xba,0xea,0x5f,0x38,0x92,0xd0,0x33,0xb5,0xa3,0x5d,0x32,0x01,0x10,0xb4,0xd3,0x1d,0x61,0x3b,0x23,0xd5,0xf0,0xfa,0x22,0x80,0xe3,0x34,0x23,0x4f,0x33,0xc2,0xd2};
    static std::uint8_t sum46[32]    = {0x7b,0x44,0xd1,0xa2,0xef,0x89,0xde,0x97,0x49,0xe6,0x66,0xaa,0x92,0x51,0x96,0x2a,0x57,0x3a,0x24,0xcd,0xe9,0x2b,0xc2,0xb0,0xcc,0x5a,0x75,0x56,0x9f,0x54,0x97,0xf2};
    static int          carry46      = 1;
    mpz_from_bytes(augend, augend46, 4);
    mpz_from_bytes(addend, addend46, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum46, sum_data, 32) != 0 || carry46 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend47[32] = {0xbf,0x15,0x6e,0x46,0x3e,0x3a,0xcc,0x8a,0x81,0xd0,0x61,0x9a,0x91,0x14,0x0b,0x51,0x86,0xee,0x7c,0x59,0x74,0xa5,0xe7,0x1c,0xd0,0x48,0xf8,0x2e,0x96,0xa7,0xbe,0xd2};
    static std::uint8_t addend47[32] = {0x4d,0x5f,0x5b,0x0b,0x82,0x7b,0xd9,0x74,0x11,0xd7,0x5e,0x32,0xdc,0x02,0x95,0xc1,0xb7,0xbe,0xc7,0x8f,0xc8,0xa7,0xbe,0x8b,0xc4,0x09,0x6c,0x14,0xc2,0x77,0x1b,0xfc};
    static std::uint8_t sum47[32]    = {0x0c,0x74,0xc9,0x51,0xc0,0xb6,0xa5,0xfe,0x93,0xa7,0xbf,0xcd,0x6d,0x16,0xa1,0x13,0x3e,0xad,0x43,0xe9,0x3d,0x4d,0xa5,0xa8,0x94,0x52,0x64,0x43,0x59,0x1e,0xda,0xce};
    static int          carry47      = 1;
    mpz_from_bytes(augend, augend47, 4);
    mpz_from_bytes(addend, addend47, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum47, sum_data, 32) != 0 || carry47 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend48[32] = {0x3e,0xa2,0x81,0xb4,0xda,0xba,0xa5,0xaf,0x40,0x4d,0xa4,0xa0,0x91,0x7f,0x50,0xd2,0x86,0x73,0x11,0x65,0xeb,0x79,0xd7,0x74,0xd6,0x45,0xe0,0xf4,0xd6,0x2d,0xa6,0x59};
    static std::uint8_t addend48[32] = {0x28,0x11,0x72,0x15,0xc9,0xe3,0x5c,0x16,0x82,0x58,0xbd,0x90,0x09,0x88,0x1c,0x65,0x38,0xde,0x24,0x32,0x58,0xf5,0xa7,0xf8,0xea,0x52,0x06,0xf5,0x24,0x28,0x12,0xc4};
    static std::uint8_t sum48[32]    = {0x66,0xb3,0xf3,0xca,0xa4,0x9e,0x01,0xc5,0xc2,0xa6,0x62,0x30,0x9b,0x07,0x6d,0x37,0xbf,0x51,0x35,0x98,0x44,0x6f,0x7f,0x6d,0xc0,0x97,0xe7,0xe9,0xfa,0x55,0xb9,0x1d};
    static int          carry48      = 0;
    mpz_from_bytes(augend, augend48, 4);
    mpz_from_bytes(addend, addend48, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum48, sum_data, 32) != 0 || carry48 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend49[32] = {0x63,0x93,0x42,0x0e,0xe8,0xe9,0xe1,0x37,0x07,0x7d,0xb3,0xf0,0xe8,0x83,0x08,0x9d,0x50,0x12,0xed,0x5b,0xe4,0x74,0x4c,0x2b,0xb8,0x4a,0xd7,0x46,0xba,0x93,0x47,0xc8};
    static std::uint8_t addend49[32] = {0xf7,0x19,0x8a,0x09,0x67,0x59,0x65,0x62,0xf8,0x22,0x0e,0x23,0xee,0x70,0x47,0x1a,0xbd,0x16,0x42,0x62,0x7d,0xad,0x30,0xa2,0xae,0x52,0x15,0x7f,0x9c,0xd9,0x2b,0x0c};
    static std::uint8_t sum49[32]    = {0x5a,0xac,0xcc,0x18,0x50,0x43,0x46,0x99,0xff,0x9f,0xc2,0x14,0xd6,0xf3,0x4f,0xb8,0x0d,0x29,0x2f,0xbe,0x62,0x21,0x7c,0xce,0x66,0x9c,0xec,0xc6,0x57,0x6c,0x72,0xd4};
    static int          carry49      = 1;
    mpz_from_bytes(augend, augend49, 4);
    mpz_from_bytes(addend, addend49, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum49, sum_data, 32) != 0 || carry49 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend50[32] = {0x2a,0x12,0x8e,0xf3,0x5b,0x12,0xf5,0xed,0x27,0x39,0xe6,0xcb,0xdb,0x57,0x15,0x36,0xd5,0x37,0x7b,0x5d,0x27,0x3d,0x2b,0xf0,0x2e,0x3f,0x60,0x99,0xc9,0x0a,0x3c,0x8e};
    static std::uint8_t addend50[32] = {0x47,0x7b,0x94,0x5e,0xb3,0x38,0x71,0x33,0x8e,0x1a,0xa2,0xdf,0x39,0xb2,0xbb,0x46,0x31,0x5f,0xd4,0xdf,0x8a,0x14,0xb2,0x55,0x0e,0x23,0xdd,0x8e,0x87,0x7e,0x5f,0x79};
    static std::uint8_t sum50[32]    = {0x71,0x8e,0x23,0x52,0x0e,0x4b,0x67,0x20,0xb5,0x54,0x89,0xab,0x15,0x09,0xd0,0x7d,0x06,0x97,0x50,0x3c,0xb1,0x51,0xde,0x45,0x3c,0x63,0x3e,0x28,0x50,0x88,0x9c,0x07};
    static int          carry50      = 0;
    mpz_from_bytes(augend, augend50, 4);
    mpz_from_bytes(addend, addend50, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum50, sum_data, 32) != 0 || carry50 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend51[32] = {0xd4,0x25,0x59,0xf4,0x85,0x1e,0x27,0xba,0xd5,0xf4,0x99,0x2f,0xa3,0x03,0xf2,0x64,0x22,0x1a,0x99,0x3e,0x45,0x9d,0xec,0xd6,0x54,0x89,0xd1,0x47,0x9e,0xea,0x36,0x80};
    static std::uint8_t addend51[32] = {0x73,0xdd,0x28,0x23,0xf5,0x89,0x22,0x40,0xaf,0xca,0xcc,0x9c,0xc4,0x83,0x06,0xca,0x08,0xa3,0x2e,0x8a,0xb9,0x2c,0x0d,0xa2,0x43,0xff,0x82,0x54,0x4d,0x99,0x74,0xe0};
    static std::uint8_t sum51[32]    = {0x48,0x02,0x82,0x18,0x7a,0xa7,0x49,0xfb,0x85,0xbf,0x65,0xcc,0x67,0x86,0xf9,0x2e,0x2a,0xbd,0xc7,0xc8,0xfe,0xc9,0xfa,0x78,0x98,0x89,0x53,0x9b,0xec,0x83,0xab,0x60};
    static int          carry51      = 1;
    mpz_from_bytes(augend, augend51, 4);
    mpz_from_bytes(addend, addend51, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum51, sum_data, 32) != 0 || carry51 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend52[32] = {0x73,0xfc,0x81,0x33,0x46,0x74,0x45,0x13,0x90,0x03,0x6c,0xe4,0x87,0xa4,0xcf,0x75,0x3b,0x9f,0xee,0x9e,0xe5,0x9d,0x53,0x56,0x6c,0x89,0xfe,0x2f,0xe6,0xff,0x97,0x2d};
    static std::uint8_t addend52[32] = {0xc7,0xbc,0x17,0xd3,0xbf,0x49,0xb4,0x01,0xc3,0x38,0x14,0x50,0x49,0x0d,0x96,0xb9,0x96,0xed,0xa1,0x0d,0xd3,0xf6,0xc9,0xc0,0x54,0x5e,0x0d,0x37,0xb6,0x8c,0x16,0x31};
    static std::uint8_t sum52[32]    = {0x3b,0xb8,0x99,0x07,0x05,0xbd,0xf9,0x15,0x53,0x3b,0x81,0x34,0xd0,0xb2,0x66,0x2e,0xd2,0x8d,0x8f,0xac,0xb9,0x94,0x1d,0x16,0xc0,0xe8,0x0b,0x67,0x9d,0x8b,0xad,0x5e};
    static int          carry52      = 1;
    mpz_from_bytes(augend, augend52, 4);
    mpz_from_bytes(addend, addend52, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum52, sum_data, 32) != 0 || carry52 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend53[32] = {0x34,0x77,0xa8,0xaa,0xb1,0x7a,0x8d,0x3a,0x42,0x9d,0xe5,0xaa,0xed,0xf2,0x9a,0xb0,0x87,0x2a,0x1c,0x45,0x02,0xaf,0xcb,0xe6,0x67,0xb1,0xd3,0xc5,0x46,0x95,0xdd,0xb1};
    static std::uint8_t addend53[32] = {0x56,0xb6,0x06,0x58,0x7c,0x4c,0xd8,0xc2,0x34,0xd7,0xe0,0xf3,0x50,0x73,0xb5,0x09,0x87,0xd2,0xfa,0x54,0x57,0x0a,0x49,0x46,0x0e,0x61,0x0a,0x1e,0x2a,0xa4,0xd8,0xa6};
    static std::uint8_t sum53[32]    = {0x8b,0x2d,0xaf,0x03,0x2d,0xc7,0x65,0xfc,0x77,0x75,0xc6,0x9e,0x3e,0x66,0x4f,0xba,0x0e,0xfd,0x16,0x99,0x59,0xba,0x15,0x2c,0x76,0x12,0xdd,0xe3,0x71,0x3a,0xb6,0x57};
    static int          carry53      = 0;
    mpz_from_bytes(augend, augend53, 4);
    mpz_from_bytes(addend, addend53, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum53, sum_data, 32) != 0 || carry53 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend54[32] = {0x27,0xe4,0x59,0x81,0x1f,0xb4,0xe3,0x0a,0xe5,0x9a,0xf6,0x1b,0xdf,0x37,0x2e,0x54,0x09,0x8f,0x87,0xc0,0xb1,0x98,0x0c,0xa9,0xbc,0xec,0x98,0x04,0x5a,0x8c,0xb2,0x34};
    static std::uint8_t addend54[32] = {0x13,0x59,0x72,0xd0,0x87,0x79,0xfd,0x08,0x4a,0x40,0x2b,0x68,0xaa,0x00,0x8f,0x90,0x2c,0xdc,0xdb,0xf4,0xe8,0x1b,0xad,0xee,0x97,0xa5,0x0d,0x69,0x3f,0x0f,0x07,0xd3};
    static std::uint8_t sum54[32]    = {0x3b,0x3d,0xcc,0x51,0xa7,0x2e,0xe0,0x13,0x2f,0xdb,0x21,0x84,0x89,0x37,0xbd,0xe4,0x36,0x6c,0x63,0xb5,0x99,0xb3,0xba,0x98,0x54,0x91,0xa5,0x6d,0x99,0x9b,0xba,0x07};
    static int          carry54      = 0;
    mpz_from_bytes(augend, augend54, 4);
    mpz_from_bytes(addend, addend54, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum54, sum_data, 32) != 0 || carry54 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend55[32] = {0x7c,0xa1,0x5c,0x15,0xb9,0xdf,0x96,0x58,0x95,0x57,0xeb,0xf4,0x40,0x69,0x8d,0x4d,0x60,0x37,0xf8,0x87,0x06,0x81,0x39,0xea,0x76,0xbb,0xa3,0x61,0xdd,0x35,0x7a,0x07};
    static std::uint8_t addend55[32] = {0x44,0x4c,0x79,0xe7,0x14,0x09,0x04,0x30,0x13,0xd1,0x83,0xbb,0xe8,0xa4,0xa5,0x7e,0xf9,0x26,0x1c,0xb2,0x0f,0xbf,0xcd,0xe4,0x03,0x2e,0xfa,0x5d,0x18,0xb7,0xde,0x18};
    static std::uint8_t sum55[32]    = {0xc0,0xed,0xd5,0xfc,0xcd,0xe8,0x9a,0x88,0xa9,0x29,0x6f,0xb0,0x29,0x0e,0x32,0xcc,0x59,0x5e,0x15,0x39,0x16,0x41,0x07,0xce,0x79,0xea,0x9d,0xbe,0xf5,0xed,0x58,0x1f};
    static int          carry55      = 0;
    mpz_from_bytes(augend, augend55, 4);
    mpz_from_bytes(addend, addend55, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum55, sum_data, 32) != 0 || carry55 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend56[32] = {0xf3,0x54,0x68,0x91,0xb2,0xc2,0xd0,0x92,0x9c,0x83,0xee,0x6e,0x31,0xb6,0xab,0x34,0x43,0x52,0xda,0x4a,0xbe,0x3f,0x9f,0x73,0xa5,0x69,0x1e,0x77,0x3f,0x03,0x77,0xe2};
    static std::uint8_t addend56[32] = {0x73,0x53,0x26,0xed,0x83,0x82,0x4e,0xba,0xe5,0x46,0x61,0x4c,0xe2,0x78,0x1a,0xd7,0x1a,0x64,0x73,0xb8,0xff,0x41,0x23,0xa1,0xcf,0x5d,0x22,0x37,0xbb,0xbc,0xba,0x79};
    static std::uint8_t sum56[32]    = {0x66,0xa7,0x8f,0x7f,0x36,0x45,0x1f,0x4d,0x81,0xca,0x4f,0xbb,0x14,0x2e,0xc6,0x0b,0x5d,0xb7,0x4e,0x03,0xbd,0x80,0xc3,0x15,0x74,0xc6,0x40,0xae,0xfa,0xc0,0x32,0x5b};
    static int          carry56      = 1;
    mpz_from_bytes(augend, augend56, 4);
    mpz_from_bytes(addend, addend56, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum56, sum_data, 32) != 0 || carry56 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend57[32] = {0x9b,0x2c,0xe1,0x77,0x68,0x4b,0xf8,0x66,0xe4,0x1d,0x77,0xf9,0xec,0x4d,0x00,0x4b,0x0b,0xe5,0x12,0x5c,0xe9,0x1d,0xe6,0x76,0x46,0x61,0x2f,0xc6,0xfb,0xa7,0x8d,0xa6};
    static std::uint8_t addend57[32] = {0x78,0xe8,0x88,0xae,0x0f,0x22,0x90,0xdd,0x6f,0xa6,0x13,0x28,0xe4,0x46,0x62,0xb6,0xf4,0x37,0xf3,0x9a,0x12,0xc7,0x6e,0xae,0x2b,0x3b,0x2c,0x8c,0x5b,0x35,0x51,0xb0};
    static std::uint8_t sum57[32]    = {0x14,0x15,0x6a,0x25,0x77,0x6e,0x89,0x44,0x53,0xc3,0x8b,0x22,0xd0,0x93,0x63,0x02,0x00,0x1d,0x05,0xf6,0xfb,0xe5,0x55,0x24,0x71,0x9c,0x5c,0x53,0x56,0xdc,0xdf,0x56};
    static int          carry57      = 1;
    mpz_from_bytes(augend, augend57, 4);
    mpz_from_bytes(addend, addend57, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum57, sum_data, 32) != 0 || carry57 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend58[32] = {0xe1,0x80,0x37,0x1a,0x04,0x74,0xd3,0xde,0x10,0xfe,0xae,0x94,0x61,0xc1,0x3d,0x05,0x67,0x3e,0xfd,0xc1,0xe5,0xd7,0xc7,0xee,0x76,0x86,0x21,0xdd,0xb0,0xf0,0x96,0x8e};
    static std::uint8_t addend58[32] = {0xb8,0x9f,0x56,0x60,0xe7,0x65,0x32,0xda,0x42,0x04,0xa0,0xa4,0x5e,0x27,0xb5,0x7f,0xe6,0x23,0x04,0xc6,0x6c,0xed,0xb3,0xf6,0x1e,0x62,0x43,0x96,0x09,0x8d,0xed,0x71};
    static std::uint8_t sum58[32]    = {0x9a,0x1f,0x8d,0x7a,0xeb,0xda,0x06,0xb8,0x53,0x03,0x4f,0x38,0xbf,0xe8,0xf2,0x85,0x4d,0x62,0x02,0x88,0x52,0xc5,0x7b,0xe4,0x94,0xe8,0x65,0x73,0xba,0x7e,0x83,0xff};
    static int          carry58      = 1;
    mpz_from_bytes(augend, augend58, 4);
    mpz_from_bytes(addend, addend58, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum58, sum_data, 32) != 0 || carry58 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend59[32] = {0x1c,0xc7,0x7a,0x37,0x7d,0x9d,0x52,0x9d,0x30,0xe0,0x31,0x16,0x23,0x0f,0xfb,0x1d,0x3f,0x8a,0xf9,0x0b,0x0d,0xa6,0x90,0xd5,0xe0,0x5c,0x32,0xe4,0x57,0xc7,0xe5,0x9c};
    static std::uint8_t addend59[32] = {0x14,0xc9,0x0d,0xe9,0xfd,0xc9,0xad,0xd8,0xc7,0xea,0x01,0x0d,0x6a,0x8d,0x92,0x9b,0xde,0xc7,0x2d,0x59,0x7c,0x0c,0xf5,0xa0,0x3f,0x0c,0xc6,0x38,0xe3,0x78,0x7c,0x1a};
    static std::uint8_t sum59[32]    = {0x31,0x90,0x88,0x21,0x7b,0x67,0x00,0x75,0xf8,0xca,0x32,0x23,0x8d,0x9d,0x8d,0xb9,0x1e,0x52,0x26,0x64,0x89,0xb3,0x86,0x76,0x1f,0x68,0xf9,0x1d,0x3b,0x40,0x61,0xb6};
    static int          carry59      = 0;
    mpz_from_bytes(augend, augend59, 4);
    mpz_from_bytes(addend, addend59, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum59, sum_data, 32) != 0 || carry59 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend60[32] = {0x2a,0xc0,0x12,0xd8,0xb6,0xde,0xc6,0xfc,0x69,0x26,0x0d,0x28,0x83,0xd9,0x8c,0x81,0x57,0x1b,0x9d,0x23,0x1d,0x71,0x2f,0xf6,0xcd,0x05,0xf1,0xeb,0x03,0xac,0x69,0x5f};
    static std::uint8_t addend60[32] = {0x0d,0xe3,0x3a,0x01,0xa1,0x71,0xed,0xe7,0x89,0x9e,0x8e,0x64,0x1a,0xce,0xe5,0x7e,0x23,0x50,0x77,0xbf,0xfb,0xe8,0xc9,0x1d,0xdb,0xc6,0x91,0xf8,0xc3,0x60,0x41,0xb7};
    static std::uint8_t sum60[32]    = {0x38,0xa3,0x4c,0xda,0x58,0x50,0xb4,0xe3,0xf2,0xc4,0x9b,0x8c,0x9e,0xa8,0x71,0xff,0x7a,0x6c,0x14,0xe3,0x19,0x59,0xf9,0x14,0xa8,0xcc,0x83,0xe3,0xc7,0x0c,0xab,0x16};
    static int          carry60      = 0;
    mpz_from_bytes(augend, augend60, 4);
    mpz_from_bytes(addend, addend60, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum60, sum_data, 32) != 0 || carry60 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend61[32] = {0x0b,0x64,0x29,0x59,0x6f,0x19,0xc4,0x06,0xd7,0x19,0x26,0x0b,0x32,0x20,0x61,0xd6,0x07,0xbb,0x19,0x23,0x67,0x37,0x26,0x33,0x35,0xa3,0x4b,0xc1,0x02,0xd6,0xc1,0x86};
    static std::uint8_t addend61[32] = {0x1c,0x6c,0xa8,0x3a,0xb3,0x65,0x63,0x75,0x88,0xf3,0x11,0xfc,0x77,0xb5,0x55,0xcd,0x9d,0x2f,0x67,0x01,0x69,0x47,0x02,0x84,0x0d,0x65,0xf5,0xe7,0xde,0x48,0x5b,0xfb};
    static std::uint8_t sum61[32]    = {0x27,0xd0,0xd1,0x94,0x22,0x7f,0x27,0x7c,0x60,0x0c,0x38,0x07,0xa9,0xd5,0xb7,0xa3,0xa4,0xea,0x80,0x24,0xd0,0x7e,0x28,0xb7,0x43,0x09,0x41,0xa8,0xe1,0x1f,0x1d,0x81};
    static int          carry61      = 0;
    mpz_from_bytes(augend, augend61, 4);
    mpz_from_bytes(addend, addend61, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum61, sum_data, 32) != 0 || carry61 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend62[32] = {0x03,0x6b,0x4a,0xe4,0x8f,0xef,0xd2,0x61,0xf1,0xab,0xdc,0x0f,0x70,0xf1,0xbf,0xde,0x32,0xb7,0x92,0x50,0x7e,0x58,0x7f,0xc7,0x02,0x22,0xee,0xd7,0x86,0x2d,0x63,0xce};
    static std::uint8_t addend62[32] = {0xab,0x0f,0x07,0x37,0x20,0x36,0x5b,0xec,0xab,0xaa,0x08,0x50,0xc5,0x0c,0x7f,0xc8,0x20,0x10,0xcc,0x21,0xb7,0x91,0x78,0x1f,0xc2,0x15,0xf8,0xd1,0x8f,0x07,0x0f,0x46};
    static std::uint8_t sum62[32]    = {0xae,0x7a,0x52,0x1b,0xb0,0x26,0x2e,0x4e,0x9d,0x55,0xe4,0x60,0x35,0xfe,0x3f,0xa6,0x52,0xc8,0x5e,0x72,0x35,0xe9,0xf7,0xe6,0xc4,0x38,0xe7,0xa9,0x15,0x34,0x73,0x14};
    static int          carry62      = 0;
    mpz_from_bytes(augend, augend62, 4);
    mpz_from_bytes(addend, addend62, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum62, sum_data, 32) != 0 || carry62 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend63[32] = {0x27,0x1a,0xc6,0x84,0x2f,0xf1,0x76,0x2d,0x96,0xa5,0x9c,0x45,0x4b,0xea,0x90,0xa8,0x1f,0x4c,0xe3,0x4f,0x30,0x9f,0x30,0x50,0x3a,0x89,0x97,0x87,0x4b,0xd4,0x03,0xf2};
    static std::uint8_t addend63[32] = {0x88,0xd1,0x9d,0x79,0x0e,0x7c,0xd9,0xdc,0x98,0xd1,0x70,0x88,0x11,0x25,0x1c,0x41,0x9c,0x19,0x4d,0x2b,0x95,0x3e,0x6f,0xa0,0x85,0xef,0xf6,0x8b,0x58,0xf3,0x70,0x55};
    static std::uint8_t sum63[32]    = {0xaf,0xec,0x63,0xfd,0x3e,0x6e,0x50,0x0a,0x2f,0x77,0x0c,0xcd,0x5d,0x0f,0xac,0xe9,0xbb,0x66,0x30,0x7a,0xc5,0xdd,0x9f,0xf0,0xc0,0x79,0x8e,0x12,0xa4,0xc7,0x74,0x47};
    static int          carry63      = 0;
    mpz_from_bytes(augend, augend63, 4);
    mpz_from_bytes(addend, addend63, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum63, sum_data, 32) != 0 || carry63 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend64[32] = {0x68,0x76,0x45,0x50,0xcb,0x0d,0xc0,0x08,0x1b,0xdf,0xe0,0xee,0x55,0xc4,0xc6,0xc7,0x61,0x45,0xc9,0x9c,0x6e,0xd2,0xd7,0xd4,0x00,0x7e,0xec,0xdc,0x45,0xd0,0x2c,0x95};
    static std::uint8_t addend64[32] = {0x89,0x96,0x05,0x8e,0x58,0xd4,0xb7,0x19,0xb5,0xe8,0x05,0xa5,0xa5,0xb3,0xc5,0x18,0x10,0xba,0xd8,0xf2,0x87,0x8c,0xb1,0xa9,0x5c,0x3f,0xe1,0x31,0x36,0x86,0x54,0x42};
    static std::uint8_t sum64[32]    = {0xf2,0x0c,0x4a,0xdf,0x23,0xe2,0x77,0x21,0xd1,0xc7,0xe6,0x93,0xfb,0x78,0x8b,0xdf,0x72,0x00,0xa2,0x8e,0xf6,0x5f,0x89,0x7d,0x5c,0xbe,0xce,0x0d,0x7c,0x56,0x80,0xd7};
    static int          carry64      = 0;
    mpz_from_bytes(augend, augend64, 4);
    mpz_from_bytes(addend, addend64, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum64, sum_data, 32) != 0 || carry64 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend65[32] = {0xe6,0x89,0x05,0xf9,0xf7,0x23,0xed,0x68,0x85,0x14,0x34,0x1a,0xf0,0x9f,0xdb,0x2e,0x12,0xee,0x5c,0xab,0xb0,0x3c,0xf8,0xbf,0x70,0x77,0x18,0xa3,0x4b,0x8f,0xc1,0x9f};
    static std::uint8_t addend65[32] = {0x70,0xba,0x72,0x6a,0xcd,0xe5,0x17,0x90,0x3f,0x30,0x99,0xd4,0x75,0xe2,0x6c,0x04,0x47,0xa6,0x6c,0x43,0xbc,0x96,0x0f,0x3a,0x4f,0x85,0x72,0x80,0xcd,0xe2,0xbb,0x88};
    static std::uint8_t sum65[32]    = {0x57,0x43,0x78,0x64,0xc5,0x09,0x04,0xf8,0xc4,0x44,0xcd,0xef,0x66,0x82,0x47,0x32,0x5a,0x94,0xc8,0xef,0x6c,0xd3,0x07,0xf9,0xbf,0xfc,0x8b,0x24,0x19,0x72,0x7d,0x27};
    static int          carry65      = 1;
    mpz_from_bytes(augend, augend65, 4);
    mpz_from_bytes(addend, addend65, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum65, sum_data, 32) != 0 || carry65 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend66[32] = {0x89,0x09,0x3e,0xca,0x46,0xe2,0xec,0xc5,0xc0,0x5a,0x7a,0xec,0x28,0x6a,0x90,0xf8,0x4b,0xcf,0xf8,0x30,0xdf,0xe1,0x75,0xe5,0xd9,0x1f,0x08,0xf9,0xd4,0x78,0x82,0x2a};
    static std::uint8_t addend66[32] = {0x19,0xa2,0xd9,0xfe,0xce,0x8d,0x20,0xfe,0x49,0xe2,0x21,0x47,0x3e,0x85,0x10,0x23,0x08,0x2c,0xc3,0xd3,0x07,0x40,0x98,0x7d,0xd3,0xa2,0xe4,0x9a,0x49,0xe4,0x2a,0x66};
    static std::uint8_t sum66[32]    = {0xa2,0xac,0x18,0xc9,0x15,0x70,0x0d,0xc4,0x0a,0x3c,0x9c,0x33,0x66,0xef,0xa1,0x1b,0x53,0xfc,0xbc,0x03,0xe7,0x22,0x0e,0x63,0xac,0xc1,0xed,0x94,0x1e,0x5c,0xac,0x90};
    static int          carry66      = 0;
    mpz_from_bytes(augend, augend66, 4);
    mpz_from_bytes(addend, addend66, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum66, sum_data, 32) != 0 || carry66 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend67[32] = {0x3b,0x55,0x77,0x88,0xd0,0x0c,0xfd,0x1b,0x6b,0x3d,0xb8,0x5e,0x4e,0x8d,0x17,0xd1,0x94,0xc0,0xd2,0x89,0x0e,0x46,0x7f,0xec,0x46,0x10,0xc2,0x4b,0xbb,0xd7,0xb9,0x43};
    static std::uint8_t addend67[32] = {0x24,0x85,0xdb,0x87,0x12,0xf4,0x0f,0xed,0xab,0xc9,0xba,0x41,0x36,0xf1,0x08,0x31,0x69,0xbc,0xc9,0xb7,0x0a,0x4d,0x12,0x34,0xd4,0xa0,0xf2,0xc8,0xc0,0xe6,0x88,0xd4};
    static std::uint8_t sum67[32]    = {0x5f,0xdb,0x53,0x0f,0xe3,0x01,0x0d,0x09,0x17,0x07,0x72,0x9f,0x85,0x7e,0x20,0x02,0xfe,0x7d,0x9c,0x40,0x18,0x93,0x92,0x21,0x1a,0xb1,0xb5,0x14,0x7c,0xbe,0x42,0x17};
    static int          carry67      = 0;
    mpz_from_bytes(augend, augend67, 4);
    mpz_from_bytes(addend, addend67, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum67, sum_data, 32) != 0 || carry67 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend68[32] = {0xdb,0x0e,0x06,0xd3,0x19,0x24,0x20,0x26,0x67,0x2d,0x08,0xf4,0x9e,0x26,0x74,0x40,0x8b,0x66,0x47,0x95,0xf4,0x95,0x39,0x6c,0x0a,0x4d,0x33,0x90,0x93,0xbf,0x78,0x50};
    static std::uint8_t addend68[32] = {0x3b,0xb3,0x8b,0x4e,0xf5,0x95,0x30,0x91,0xbe,0xca,0x58,0x8a,0x21,0x56,0x62,0x42,0x83,0xe6,0x26,0x7e,0x75,0x99,0xa3,0x9c,0x03,0x02,0x03,0xc8,0x94,0x3b,0x82,0xe1};
    static std::uint8_t sum68[32]    = {0x16,0xc1,0x92,0x22,0x0e,0xb9,0x50,0xb8,0x25,0xf7,0x61,0x7e,0xbf,0x7c,0xd6,0x83,0x0f,0x4c,0x6e,0x14,0x6a,0x2e,0xdd,0x08,0x0d,0x4f,0x37,0x59,0x27,0xfa,0xfb,0x31};
    static int          carry68      = 1;
    mpz_from_bytes(augend, augend68, 4);
    mpz_from_bytes(addend, addend68, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum68, sum_data, 32) != 0 || carry68 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend69[32] = {0x4c,0x32,0x3d,0x6f,0xdb,0x04,0xff,0x38,0xec,0xb7,0x6c,0x35,0x18,0x95,0x15,0xfa,0xa5,0xc8,0x03,0xde,0x4c,0x8b,0x3a,0xc5,0x5d,0xb3,0x24,0x93,0x78,0x30,0xaa,0xf6};
    static std::uint8_t addend69[32] = {0x8f,0x6a,0x6a,0xe1,0x24,0x0e,0x1f,0x4f,0x07,0xaa,0xec,0x19,0x97,0x67,0xbb,0xfc,0x01,0x1b,0xb0,0xc9,0x1a,0x99,0x2f,0x5e,0xab,0x5e,0x7b,0x4d,0xe4,0xf9,0x94,0xe4};
    static std::uint8_t sum69[32]    = {0xdb,0x9c,0xa8,0x50,0xff,0x13,0x1e,0x87,0xf4,0x62,0x58,0x4e,0xaf,0xfc,0xd1,0xf6,0xa6,0xe3,0xb4,0xa7,0x67,0x24,0x6a,0x24,0x09,0x11,0x9f,0xe1,0x5d,0x2a,0x3f,0xda};
    static int          carry69      = 0;
    mpz_from_bytes(augend, augend69, 4);
    mpz_from_bytes(addend, addend69, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum69, sum_data, 32) != 0 || carry69 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend70[32] = {0x3b,0x69,0x89,0xd5,0xe1,0x9e,0x61,0x08,0x45,0x15,0x84,0x57,0xcb,0x3b,0xa4,0x34,0x38,0x64,0x5e,0x64,0x48,0x3c,0x4a,0x5a,0xa6,0x7f,0x6c,0xf1,0x5a,0x31,0x4c,0x3b};
    static std::uint8_t addend70[32] = {0xda,0x03,0x50,0x70,0x00,0x3d,0x5c,0x68,0x22,0xa6,0xb3,0x04,0x07,0x99,0x8b,0x1c,0xd6,0x4e,0x7a,0x00,0x6f,0xcd,0xb6,0x94,0x33,0x7a,0xda,0x23,0xed,0x97,0xb2,0x86};
    static std::uint8_t sum70[32]    = {0x15,0x6c,0xda,0x45,0xe1,0xdb,0xbd,0x70,0x67,0xbc,0x37,0x5b,0xd2,0xd5,0x2f,0x51,0x0e,0xb2,0xd8,0x64,0xb8,0x0a,0x00,0xee,0xd9,0xfa,0x47,0x15,0x47,0xc8,0xfe,0xc1};
    static int          carry70      = 1;
    mpz_from_bytes(augend, augend70, 4);
    mpz_from_bytes(addend, addend70, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum70, sum_data, 32) != 0 || carry70 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend71[32] = {0xac,0xf1,0x1a,0xfe,0xa2,0xdf,0x0c,0xcd,0xac,0xf2,0x38,0x66,0x21,0x33,0x15,0xe1,0x3f,0x5b,0xdf,0xe6,0x2c,0x7c,0x09,0xef,0x78,0x78,0x7d,0xa4,0x41,0x43,0x0f,0x1e};
    static std::uint8_t addend71[32] = {0x48,0xff,0xa5,0x26,0x64,0x1c,0x13,0x1a,0xeb,0xa3,0x49,0xc8,0xf3,0xbf,0xdf,0x21,0x6b,0x92,0xf6,0xde,0xbf,0x38,0x8a,0x3d,0x7d,0xb8,0x96,0x2f,0x83,0x3d,0x91,0x00};
    static std::uint8_t sum71[32]    = {0xf5,0xf0,0xc0,0x25,0x06,0xfb,0x1f,0xe8,0x98,0x95,0x82,0x2f,0x14,0xf2,0xf5,0x02,0xaa,0xee,0xd6,0xc4,0xeb,0xb4,0x94,0x2c,0xf6,0x31,0x13,0xd3,0xc4,0x80,0xa0,0x1e};
    static int          carry71      = 0;
    mpz_from_bytes(augend, augend71, 4);
    mpz_from_bytes(addend, addend71, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum71, sum_data, 32) != 0 || carry71 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend72[32] = {0xee,0x1c,0xfd,0x6d,0x9a,0xb7,0xd3,0x17,0xac,0x04,0x1d,0x02,0xb8,0x1c,0x4f,0x63,0xe8,0xf6,0x42,0x71,0xee,0x00,0xe6,0xd0,0x51,0xeb,0x61,0x82,0x7f,0x2c,0xc9,0x91};
    static std::uint8_t addend72[32] = {0x7d,0x6b,0xc8,0xfb,0x0c,0x9d,0xd9,0x6f,0x0f,0x19,0x61,0xcb,0xab,0x3a,0xf3,0x30,0xc5,0x97,0xd3,0x87,0xc0,0xbc,0x6e,0xc6,0x37,0xd4,0xe7,0xab,0xe8,0xc3,0x43,0x27};
    static std::uint8_t sum72[32]    = {0x6b,0x88,0xc6,0x68,0xa7,0x55,0xac,0x86,0xbb,0x1d,0x7e,0xce,0x63,0x57,0x42,0x94,0xae,0x8e,0x15,0xf9,0xae,0xbd,0x55,0x96,0x89,0xc0,0x49,0x2e,0x67,0xf0,0x0c,0xb8};
    static int          carry72      = 1;
    mpz_from_bytes(augend, augend72, 4);
    mpz_from_bytes(addend, addend72, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum72, sum_data, 32) != 0 || carry72 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend73[32] = {0xc2,0xb6,0xb8,0x80,0x3c,0x4a,0xba,0x55,0xa3,0x12,0x69,0xe1,0xdc,0xfc,0x7a,0xd7,0xc3,0x8d,0x72,0xd2,0x4e,0xb9,0xe6,0x52,0x79,0x18,0x40,0x16,0x77,0x4d,0x95,0x52};
    static std::uint8_t addend73[32] = {0x7d,0x4e,0x6b,0xcd,0x35,0xaf,0x57,0xa3,0x8f,0x8d,0xb1,0x92,0x00,0x5d,0xe6,0x9f,0xf7,0x20,0x58,0xb9,0x28,0xd2,0xfb,0x8d,0xf4,0x2d,0x60,0xdc,0xc2,0xcc,0xed,0x62};
    static std::uint8_t sum73[32]    = {0x40,0x05,0x24,0x4d,0x71,0xfa,0x11,0xf9,0x32,0xa0,0x1b,0x73,0xdd,0x5a,0x61,0x77,0xba,0xad,0xcb,0x8b,0x77,0x8c,0xe1,0xe0,0x6d,0x45,0xa0,0xf3,0x3a,0x1a,0x82,0xb4};
    static int          carry73      = 1;
    mpz_from_bytes(augend, augend73, 4);
    mpz_from_bytes(addend, addend73, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum73, sum_data, 32) != 0 || carry73 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend74[32] = {0x45,0x00,0x11,0xeb,0x50,0xf2,0xfb,0xed,0x24,0x4f,0x16,0x1e,0xc0,0x9d,0xa6,0x52,0x80,0x72,0xd4,0xc6,0xdf,0x9f,0x70,0x9e,0x5a,0xc3,0x14,0xcd,0xdd,0x69,0x47,0x00};
    static std::uint8_t addend74[32] = {0x51,0x38,0xee,0x08,0x9f,0xa1,0x29,0x11,0x15,0x69,0xfe,0xdc,0x55,0xf6,0x3f,0x72,0x2b,0x26,0xa7,0x80,0x34,0xa7,0xeb,0xf5,0xe7,0x63,0x0b,0x38,0xfb,0xb3,0x03,0xbd};
    static std::uint8_t sum74[32]    = {0x96,0x38,0xff,0xf3,0xf0,0x94,0x24,0xfe,0x39,0xb9,0x14,0xfb,0x16,0x93,0xe5,0xc4,0xab,0x99,0x7c,0x47,0x14,0x47,0x5c,0x94,0x42,0x26,0x20,0x06,0xd9,0x1c,0x4a,0xbd};
    static int          carry74      = 0;
    mpz_from_bytes(augend, augend74, 4);
    mpz_from_bytes(addend, addend74, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum74, sum_data, 32) != 0 || carry74 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend75[32] = {0x72,0xcb,0x2a,0xd3,0x14,0x99,0x5b,0x0b,0x42,0x41,0x84,0xf4,0x82,0xf2,0xcc,0xc6,0xef,0x14,0xe9,0x7c,0x3a,0x49,0x7e,0xae,0x72,0x10,0x53,0x81,0x6f,0xb8,0x87,0xb0};
    static std::uint8_t addend75[32] = {0xa6,0x40,0x2c,0x7b,0x14,0xba,0xe7,0xd4,0x41,0x9f,0x29,0x24,0x10,0x9f,0x41,0xf6,0x26,0x2a,0xc9,0x9f,0x15,0x98,0x9f,0x87,0x72,0x47,0xc0,0xaa,0x4c,0x93,0xfc,0xa1};
    static std::uint8_t sum75[32]    = {0x19,0x0b,0x57,0x4e,0x29,0x54,0x42,0xdf,0x83,0xe0,0xae,0x18,0x93,0x92,0x0e,0xbd,0x15,0x3f,0xb3,0x1b,0x4f,0xe2,0x1e,0x35,0xe4,0x58,0x14,0x2b,0xbc,0x4c,0x84,0x51};
    static int          carry75      = 1;
    mpz_from_bytes(augend, augend75, 4);
    mpz_from_bytes(addend, addend75, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum75, sum_data, 32) != 0 || carry75 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend76[32] = {0x46,0x89,0xd3,0xf6,0x54,0x11,0x4b,0x5c,0x42,0xfe,0xa6,0x24,0xfe,0x75,0xac,0x81,0xd9,0x51,0x2a,0xc7,0x59,0x12,0xd5,0x6f,0x9b,0x8e,0x20,0xf7,0xe5,0x0a,0xbd,0x50};
    static std::uint8_t addend76[32] = {0x20,0x9a,0x3f,0x50,0xd8,0x6d,0xd7,0x61,0xe8,0x31,0x85,0x26,0x3d,0x96,0x16,0xb5,0x70,0x1e,0xdd,0x2e,0xc0,0xf4,0xe5,0x1f,0xe2,0x00,0x3b,0x0b,0x2d,0x58,0xd6,0x01};
    static std::uint8_t sum76[32]    = {0x67,0x24,0x13,0x47,0x2c,0x7f,0x22,0xbe,0x2b,0x30,0x2b,0x4b,0x3c,0x0b,0xc3,0x37,0x49,0x70,0x07,0xf6,0x1a,0x07,0xba,0x8f,0x7d,0x8e,0x5c,0x03,0x12,0x63,0x93,0x51};
    static int          carry76      = 0;
    mpz_from_bytes(augend, augend76, 4);
    mpz_from_bytes(addend, addend76, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum76, sum_data, 32) != 0 || carry76 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend77[32] = {0xca,0x19,0x03,0x72,0x35,0x43,0xb2,0x11,0x65,0x29,0xfb,0x15,0xc4,0xb8,0x7f,0xe7,0x23,0xc0,0xa9,0x9a,0x90,0xed,0x33,0x63,0xd1,0x3b,0x24,0xcf,0x04,0x16,0xc1,0x0d};
    static std::uint8_t addend77[32] = {0x7c,0x74,0x10,0xf0,0xce,0x13,0x6c,0xd2,0xc6,0x20,0x35,0xae,0xe8,0x94,0xa0,0x28,0x51,0x08,0xdb,0x83,0x7b,0x8c,0x39,0x7a,0xf1,0x56,0xce,0x27,0x16,0xca,0x28,0x9c};
    static std::uint8_t sum77[32]    = {0x46,0x8d,0x14,0x63,0x03,0x57,0x1e,0xe4,0x2b,0x4a,0x30,0xc4,0xad,0x4d,0x20,0x0f,0x74,0xc9,0x85,0x1e,0x0c,0x79,0x6c,0xde,0xc2,0x91,0xf2,0xf6,0x1a,0xe0,0xe9,0xa9};
    static int          carry77      = 1;
    mpz_from_bytes(augend, augend77, 4);
    mpz_from_bytes(addend, addend77, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum77, sum_data, 32) != 0 || carry77 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend78[32] = {0xf3,0x40,0x46,0x14,0x45,0x41,0xff,0xb9,0xd4,0x1d,0x4d,0x56,0x53,0xf6,0xfc,0x1c,0xe4,0x2f,0x6c,0x57,0x86,0x97,0xa3,0xf1,0x4b,0x57,0xbb,0x06,0x6e,0x6d,0x47,0x03};
    static std::uint8_t addend78[32] = {0xf5,0x24,0x0b,0x9e,0x15,0xa9,0x1f,0xd0,0x38,0x5f,0x02,0x84,0xb8,0x19,0x84,0x39,0x0d,0x60,0xcf,0xbe,0x6b,0x5d,0x2e,0xa3,0xe3,0x0a,0x9c,0x3c,0x6a,0xee,0x23,0xd6};
    static std::uint8_t sum78[32]    = {0xe8,0x64,0x51,0xb2,0x5a,0xeb,0x1f,0x8a,0x0c,0x7c,0x4f,0xdb,0x0c,0x10,0x80,0x55,0xf1,0x90,0x3c,0x15,0xf1,0xf4,0xd2,0x95,0x2e,0x62,0x57,0x42,0xd9,0x5b,0x6a,0xd9};
    static int          carry78      = 1;
    mpz_from_bytes(augend, augend78, 4);
    mpz_from_bytes(addend, addend78, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum78, sum_data, 32) != 0 || carry78 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend79[32] = {0xa2,0x3c,0x82,0x2e,0xbe,0x79,0x0e,0x0b,0xd8,0x0f,0x4d,0x6b,0x59,0x3d,0x10,0xfd,0x69,0x23,0xcc,0x69,0xc9,0x6a,0x60,0xed,0xb0,0x3a,0x25,0xcf,0x21,0x72,0xb3,0xdd};
    static std::uint8_t addend79[32] = {0x04,0xf1,0x00,0xbc,0xe8,0x3f,0xad,0x74,0x83,0x8f,0x96,0xc9,0x8f,0x55,0x46,0x65,0xc7,0xa9,0x7d,0xdf,0x23,0xb1,0x1f,0x6e,0x6c,0x8f,0xc8,0xff,0xc4,0xdd,0xda,0xad};
    static std::uint8_t sum79[32]    = {0xa7,0x2d,0x82,0xeb,0xa6,0xb8,0xbb,0x80,0x5b,0x9e,0xe4,0x34,0xe8,0x92,0x57,0x63,0x30,0xcd,0x4a,0x48,0xed,0x1b,0x80,0x5c,0x1c,0xc9,0xee,0xce,0xe6,0x50,0x8e,0x8a};
    static int          carry79      = 0;
    mpz_from_bytes(augend, augend79, 4);
    mpz_from_bytes(addend, addend79, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum79, sum_data, 32) != 0 || carry79 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend80[32] = {0x39,0xc8,0xc1,0x8d,0xc8,0x62,0xb9,0x38,0x58,0x3c,0x82,0xe8,0x53,0x54,0xfb,0x74,0x54,0x84,0xfa,0x28,0x72,0xfc,0x7f,0x87,0x97,0xa2,0x4f,0xb7,0x4e,0xe1,0x54,0x57};
    static std::uint8_t addend80[32] = {0x97,0xf7,0x30,0xca,0x67,0x64,0x19,0xdf,0x9d,0xc2,0x69,0xb3,0x6d,0xf3,0x09,0xee,0xd6,0x47,0xd1,0x7b,0xf7,0xff,0xe0,0x17,0x2b,0x1e,0x44,0x52,0x87,0x18,0x84,0x5a};
    static std::uint8_t sum80[32]    = {0xd1,0xbf,0xf2,0x58,0x2f,0xc6,0xd3,0x17,0xf5,0xfe,0xec,0x9b,0xc1,0x48,0x05,0x63,0x2a,0xcc,0xcb,0xa4,0x6a,0xfc,0x5f,0x9e,0xc2,0xc0,0x94,0x09,0xd5,0xf9,0xd8,0xb1};
    static int          carry80      = 0;
    mpz_from_bytes(augend, augend80, 4);
    mpz_from_bytes(addend, addend80, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum80, sum_data, 32) != 0 || carry80 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend81[32] = {0xc0,0x99,0x27,0x67,0x35,0x0f,0xbe,0x91,0x08,0x43,0x57,0x0f,0x7b,0x32,0x2f,0x0c,0x7e,0x3f,0xff,0xd2,0xdd,0x34,0x61,0x85,0xb7,0x1a,0xa4,0xd4,0xe8,0xd2,0xf0,0xea};
    static std::uint8_t addend81[32] = {0x76,0x43,0x8f,0x45,0x1f,0x5d,0x28,0xd9,0xe5,0x63,0x8f,0xfd,0xd3,0x4c,0xb9,0x38,0x1a,0x3d,0xe0,0x1f,0xb8,0x98,0x70,0xec,0x67,0x72,0x74,0x53,0x2c,0x77,0x40,0xbf};
    static std::uint8_t sum81[32]    = {0x36,0xdc,0xb6,0xac,0x54,0x6c,0xe7,0x6a,0xed,0xa6,0xe7,0x0d,0x4e,0x7e,0xe8,0x44,0x98,0x7d,0xdf,0xf2,0x95,0xcc,0xd2,0x72,0x1e,0x8d,0x19,0x28,0x15,0x4a,0x31,0xa9};
    static int          carry81      = 1;
    mpz_from_bytes(augend, augend81, 4);
    mpz_from_bytes(addend, addend81, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum81, sum_data, 32) != 0 || carry81 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend82[32] = {0xf3,0xa6,0x1d,0x04,0xcf,0x41,0x1a,0x51,0x4b,0x0f,0xc0,0x53,0x70,0x1c,0x0b,0xf0,0x33,0xf0,0x4d,0x54,0x73,0xa0,0x0c,0x9b,0x91,0xc3,0xc0,0xa5,0x9c,0xf4,0x3a,0x42};
    static std::uint8_t addend82[32] = {0x19,0xb3,0x36,0xa9,0x4b,0x72,0xd8,0x8d,0x4f,0x5e,0x93,0x12,0xe0,0xe9,0x12,0xef,0xa4,0xfd,0xb8,0xd3,0x8a,0xf3,0x2d,0xda,0x07,0x62,0xd1,0x3a,0x92,0xb1,0x99,0xe6};
    static std::uint8_t sum82[32]    = {0x0d,0x59,0x53,0xae,0x1a,0xb3,0xf2,0xde,0x9a,0x6e,0x53,0x66,0x51,0x05,0x1e,0xdf,0xd8,0xee,0x06,0x27,0xfe,0x93,0x3a,0x75,0x99,0x26,0x91,0xe0,0x2f,0xa5,0xd4,0x28};
    static int          carry82      = 1;
    mpz_from_bytes(augend, augend82, 4);
    mpz_from_bytes(addend, addend82, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum82, sum_data, 32) != 0 || carry82 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend83[32] = {0x71,0x91,0x2f,0x7a,0xf2,0x0f,0x08,0x73,0x5e,0xe5,0x4c,0xab,0xfc,0x3e,0xdd,0xa6,0x01,0xd8,0x52,0x25,0x1e,0xb2,0xe8,0x95,0x7d,0x31,0x60,0xe0,0x8a,0x45,0x9b,0x6a};
    static std::uint8_t addend83[32] = {0x22,0xd6,0x62,0x72,0xe5,0x83,0xc7,0x2d,0x58,0x34,0x20,0x4c,0x31,0xe0,0x22,0x7c,0x8d,0x88,0x14,0x9b,0x96,0xf4,0x70,0x36,0x3f,0x5a,0x0c,0x88,0x82,0x5a,0xf0,0xbf};
    static std::uint8_t sum83[32]    = {0x94,0x67,0x91,0xed,0xd7,0x92,0xcf,0xa0,0xb7,0x19,0x6c,0xf8,0x2e,0x1f,0x00,0x22,0x8f,0x60,0x66,0xc0,0xb5,0xa7,0x58,0xcb,0xbc,0x8b,0x6d,0x69,0x0c,0xa0,0x8c,0x29};
    static int          carry83      = 0;
    mpz_from_bytes(augend, augend83, 4);
    mpz_from_bytes(addend, addend83, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum83, sum_data, 32) != 0 || carry83 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend84[32] = {0x03,0xef,0xae,0x6d,0x7e,0x0d,0xa7,0x4d,0xd6,0xa1,0x53,0x3f,0x11,0xf6,0x30,0x29,0xb5,0xfc,0x29,0x8b,0x3e,0x16,0x75,0xb1,0x8e,0x4f,0x23,0x73,0x71,0x23,0x01,0xbf};
    static std::uint8_t addend84[32] = {0x61,0xb4,0x7b,0x7a,0x55,0xdd,0xa2,0x9c,0x88,0xba,0x04,0x40,0x03,0x97,0x31,0xb4,0xac,0xa6,0xc9,0xc0,0x68,0xbe,0x9d,0xce,0xdf,0xa4,0x08,0x29,0x29,0x96,0xb9,0x13};
    static std::uint8_t sum84[32]    = {0x65,0xa4,0x29,0xe7,0xd3,0xeb,0x49,0xea,0x5f,0x5b,0x57,0x7f,0x15,0x8d,0x61,0xde,0x62,0xa2,0xf3,0x4b,0xa6,0xd5,0x13,0x80,0x6d,0xf3,0x2b,0x9c,0x9a,0xb9,0xba,0xd2};
    static int          carry84      = 0;
    mpz_from_bytes(augend, augend84, 4);
    mpz_from_bytes(addend, addend84, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum84, sum_data, 32) != 0 || carry84 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend85[32] = {0x2a,0x82,0x15,0x10,0xe5,0xd8,0x6e,0x85,0xf4,0xd4,0x52,0xdd,0x07,0x98,0xd6,0x60,0x3f,0x35,0xbe,0xa6,0x35,0xbf,0xaa,0x9b,0xa4,0xc2,0x86,0xfd,0x5a,0x4a,0x54,0xdc};
    static std::uint8_t addend85[32] = {0x00,0xba,0x9e,0x5f,0x12,0x32,0x2f,0xd4,0xe5,0x98,0x08,0x07,0x09,0x92,0x77,0xd3,0x7b,0x5f,0xc4,0x8a,0x93,0x9f,0x39,0xbc,0x0b,0xaf,0xc7,0x1e,0xe8,0xc7,0xb5,0x4a};
    static std::uint8_t sum85[32]    = {0x2b,0x3c,0xb3,0x6f,0xf8,0x0a,0x9e,0x5a,0xda,0x6c,0x5a,0xe4,0x11,0x2b,0x4e,0x33,0xba,0x95,0x83,0x30,0xc9,0x5e,0xe4,0x57,0xb0,0x72,0x4e,0x1c,0x43,0x12,0x0a,0x26};
    static int          carry85      = 0;
    mpz_from_bytes(augend, augend85, 4);
    mpz_from_bytes(addend, addend85, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum85, sum_data, 32) != 0 || carry85 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend86[32] = {0xf4,0xae,0x7c,0xc4,0x3f,0x5e,0x7e,0xcf,0x1f,0x6f,0x0a,0x07,0x8c,0xc7,0x96,0x3e,0x9f,0xfb,0x75,0x86,0x34,0xdf,0xec,0x83,0x8d,0x57,0xc2,0x26,0xb0,0xd9,0xe0,0x50};
    static std::uint8_t addend86[32] = {0xd9,0xe0,0xca,0x50,0xdf,0x7f,0x1d,0xae,0xf2,0xa5,0xbc,0xdd,0xde,0x52,0xb9,0xa1,0x8e,0xbd,0x7a,0x41,0x39,0xf9,0x1f,0xc2,0x6d,0xc0,0x44,0x76,0xfb,0xfa,0xed,0xa6};
    static std::uint8_t sum86[32]    = {0xce,0x8f,0x47,0x15,0x1e,0xdd,0x9c,0x7e,0x12,0x14,0xc6,0xe5,0x6b,0x1a,0x4f,0xe0,0x2e,0xb8,0xef,0xc7,0x6e,0xd9,0x0c,0x45,0xfb,0x18,0x06,0x9d,0xac,0xd4,0xcd,0xf6};
    static int          carry86      = 1;
    mpz_from_bytes(augend, augend86, 4);
    mpz_from_bytes(addend, addend86, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum86, sum_data, 32) != 0 || carry86 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend87[32] = {0x09,0xa3,0xb5,0x04,0xcd,0x3a,0x64,0x67,0xb0,0xbd,0x2a,0xe7,0x0b,0x06,0x10,0x4b,0x7b,0x21,0x06,0x42,0x92,0xdb,0xc1,0x07,0x6a,0x0c,0xaf,0xaf,0xc4,0x57,0xd0,0xdf};
    static std::uint8_t addend87[32] = {0x1b,0xa7,0xeb,0x8d,0xe2,0x6a,0x74,0xe6,0x93,0xa4,0x81,0x0e,0x36,0x2e,0x3c,0x6d,0x45,0x6c,0xd2,0xae,0xb4,0x90,0x01,0x3d,0xd3,0xd4,0xdc,0x35,0x6d,0x87,0x12,0x81};
    static std::uint8_t sum87[32]    = {0x25,0x4b,0xa0,0x92,0xaf,0xa4,0xd9,0x4e,0x44,0x61,0xab,0xf5,0x41,0x34,0x4c,0xb8,0xc0,0x8d,0xd8,0xf1,0x47,0x6b,0xc2,0x45,0x3d,0xe1,0x8b,0xe5,0x31,0xde,0xe3,0x60};
    static int          carry87      = 0;
    mpz_from_bytes(augend, augend87, 4);
    mpz_from_bytes(addend, addend87, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum87, sum_data, 32) != 0 || carry87 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend88[32] = {0x5a,0x93,0xa9,0xaa,0xc5,0x59,0xe1,0x1f,0x46,0x4f,0x9e,0xc3,0x66,0xdc,0x22,0x65,0x73,0x65,0xb4,0xea,0x20,0x42,0xfd,0x76,0x39,0x0e,0xc7,0xfd,0x48,0xa0,0xb5,0xfc};
    static std::uint8_t addend88[32] = {0x40,0x25,0xe7,0xc3,0xdb,0xc9,0xc2,0xb0,0xc0,0xba,0x07,0xb9,0x73,0xa6,0xa9,0xdc,0xd7,0x1b,0xfd,0x50,0x57,0x06,0x55,0x28,0x45,0xf4,0xa6,0xa9,0x70,0x37,0x0d,0x6a};
    static std::uint8_t sum88[32]    = {0x9a,0xb9,0x91,0x6e,0xa1,0x23,0xa3,0xd0,0x07,0x09,0xa6,0x7c,0xda,0x82,0xcc,0x42,0x4a,0x81,0xb2,0x3a,0x77,0x49,0x52,0x9e,0x7f,0x03,0x6e,0xa6,0xb8,0xd7,0xc3,0x66};
    static int          carry88      = 0;
    mpz_from_bytes(augend, augend88, 4);
    mpz_from_bytes(addend, addend88, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum88, sum_data, 32) != 0 || carry88 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend89[32] = {0xbb,0x46,0x12,0x2f,0x5a,0xe0,0xd0,0xa9,0x34,0xf2,0xb7,0x5b,0x08,0xf1,0x4e,0x1b,0x0a,0xcb,0x5e,0x01,0x01,0x0e,0x9e,0x0a,0xa5,0xe4,0xb4,0x51,0xd1,0x0f,0x5c,0x1a};
    static std::uint8_t addend89[32] = {0x18,0xdc,0x7e,0xdb,0xb0,0xc1,0xda,0x55,0x81,0x76,0xa9,0xfe,0xfe,0x80,0xd5,0xce,0xd1,0xb5,0x8c,0x33,0x9b,0x45,0x29,0x2a,0x31,0x44,0x80,0xfc,0x1d,0x63,0x84,0xf2};
    static std::uint8_t sum89[32]    = {0xd4,0x22,0x91,0x0b,0x0b,0xa2,0xaa,0xfe,0xb6,0x69,0x61,0x5a,0x07,0x72,0x23,0xe9,0xdc,0x80,0xea,0x34,0x9c,0x53,0xc7,0x34,0xd7,0x29,0x35,0x4d,0xee,0x72,0xe1,0x0c};
    static int          carry89      = 0;
    mpz_from_bytes(augend, augend89, 4);
    mpz_from_bytes(addend, addend89, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum89, sum_data, 32) != 0 || carry89 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend90[32] = {0x9a,0xd7,0xcf,0x1b,0x30,0xa3,0x71,0x16,0x73,0x5b,0xa9,0xd4,0xcf,0x9d,0xa4,0x5e,0x63,0x12,0x80,0x00,0x00,0x49,0xc7,0x13,0x4a,0x3e,0xe2,0xcd,0xc9,0x5c,0x0f,0x7c};
    static std::uint8_t addend90[32] = {0xb6,0x80,0xd1,0x03,0x15,0xfc,0xe2,0xbc,0x4c,0x38,0xee,0x11,0x22,0xe6,0xc8,0x44,0x9c,0x87,0xcc,0xfa,0xaf,0x98,0xdd,0x9b,0xa6,0xc6,0x39,0x52,0x43,0x78,0x9f,0xd7};
    static std::uint8_t sum90[32]    = {0x51,0x58,0xa0,0x1e,0x46,0xa0,0x53,0xd2,0xbf,0x94,0x97,0xe5,0xf2,0x84,0x6c,0xa2,0xff,0x9a,0x4c,0xfa,0xaf,0xe2,0xa4,0xae,0xf1,0x05,0x1c,0x20,0x0c,0xd4,0xaf,0x53};
    static int          carry90      = 1;
    mpz_from_bytes(augend, augend90, 4);
    mpz_from_bytes(addend, addend90, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum90, sum_data, 32) != 0 || carry90 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend91[32] = {0x34,0x29,0x2e,0x07,0x85,0x29,0x21,0x90,0xf4,0x3e,0x66,0x09,0x37,0x7d,0x64,0x86,0xb9,0x48,0x93,0xa5,0x99,0x80,0x13,0xed,0xac,0x2c,0x1d,0xa7,0xf2,0x4b,0xaa,0xac};
    static std::uint8_t addend91[32] = {0x71,0xc0,0xcd,0xd0,0x0d,0x78,0x6d,0x1d,0x58,0x20,0x0e,0x5d,0x8a,0x1f,0x4c,0xac,0x3d,0x7c,0x9e,0xfb,0x0c,0x07,0xb5,0x58,0x5d,0x2d,0x7f,0xbd,0x65,0xb3,0xa2,0xc3};
    static std::uint8_t sum91[32]    = {0xa5,0xe9,0xfb,0xd7,0x92,0xa1,0x8e,0xae,0x4c,0x5e,0x74,0x66,0xc1,0x9c,0xb1,0x32,0xf6,0xc5,0x32,0xa0,0xa5,0x87,0xc9,0x46,0x09,0x59,0x9d,0x65,0x57,0xff,0x4d,0x6f};
    static int          carry91      = 0;
    mpz_from_bytes(augend, augend91, 4);
    mpz_from_bytes(addend, addend91, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum91, sum_data, 32) != 0 || carry91 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend92[32] = {0xb2,0x59,0xcd,0x59,0xcc,0xd9,0xa9,0xce,0xff,0xcc,0x61,0xee,0xcb,0xd9,0x88,0x67,0x51,0x6b,0x4f,0xc0,0xf3,0xfb,0xbc,0x26,0x76,0x9b,0xdf,0xdc,0xaa,0x09,0x59,0xd2};
    static std::uint8_t addend92[32] = {0xee,0x2d,0x49,0x1b,0xc8,0xfe,0x2b,0xf8,0x73,0xc8,0xf0,0xe4,0x75,0x58,0xc4,0x97,0x7b,0xdd,0x68,0x7c,0x08,0xcf,0x01,0x75,0xab,0x0d,0x5f,0x99,0xec,0x10,0x96,0x42};
    static std::uint8_t sum92[32]    = {0xa0,0x87,0x16,0x75,0x95,0xd7,0xd5,0xc7,0x73,0x95,0x52,0xd3,0x41,0x32,0x4c,0xfe,0xcd,0x48,0xb8,0x3c,0xfc,0xca,0xbd,0x9c,0x21,0xa9,0x3f,0x76,0x96,0x19,0xf0,0x14};
    static int          carry92      = 1;
    mpz_from_bytes(augend, augend92, 4);
    mpz_from_bytes(addend, addend92, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum92, sum_data, 32) != 0 || carry92 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend93[32] = {0xba,0x86,0x8f,0x0f,0x1b,0xd0,0x8f,0x71,0x8a,0xb4,0x31,0x2a,0x11,0x0e,0xae,0xe5,0xdd,0xd9,0xd5,0x88,0x48,0xba,0x41,0xf4,0x7c,0x98,0xd2,0x73,0x1a,0xc8,0xdf,0xc0};
    static std::uint8_t addend93[32] = {0x25,0xdf,0x26,0x03,0xb6,0xf0,0x42,0xf6,0x96,0xc4,0x57,0x81,0xdc,0x85,0x73,0xd9,0xd6,0xb7,0x35,0xa6,0xed,0x72,0xc3,0xc4,0xcf,0x2f,0x47,0xa3,0xdd,0x78,0x55,0x46};
    static std::uint8_t sum93[32]    = {0xe0,0x65,0xb5,0x12,0xd2,0xc0,0xd2,0x68,0x21,0x78,0x88,0xab,0xed,0x94,0x22,0xbf,0xb4,0x91,0x0b,0x2f,0x36,0x2d,0x05,0xb9,0x4b,0xc8,0x1a,0x16,0xf8,0x41,0x35,0x06};
    static int          carry93      = 0;
    mpz_from_bytes(augend, augend93, 4);
    mpz_from_bytes(addend, addend93, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum93, sum_data, 32) != 0 || carry93 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend94[32] = {0xf9,0x76,0x3f,0x96,0xc1,0xe1,0xb6,0x26,0x5d,0x3f,0x50,0xbf,0x13,0xab,0xdf,0x3b,0x36,0x21,0x01,0x0c,0xc7,0xe4,0xed,0x56,0x29,0x90,0xc3,0x9c,0x99,0xf8,0x24,0x51};
    static std::uint8_t addend94[32] = {0x10,0xf1,0x7b,0xaa,0xf0,0x95,0x04,0x07,0x3f,0xeb,0x6e,0x9b,0xb5,0xa4,0x89,0x67,0x7e,0x09,0xb5,0xd7,0x7b,0x0b,0x21,0x74,0xc7,0x0d,0xc0,0xaf,0xf3,0x20,0x82,0xce};
    static std::uint8_t sum94[32]    = {0x0a,0x67,0xbb,0x41,0xb2,0x76,0xba,0x2d,0x9d,0x2a,0xbf,0x5a,0xc9,0x50,0x68,0xa2,0xb4,0x2a,0xb6,0xe4,0x42,0xf0,0x0e,0xca,0xf0,0x9e,0x84,0x4c,0x8d,0x18,0xa7,0x1f};
    static int          carry94      = 1;
    mpz_from_bytes(augend, augend94, 4);
    mpz_from_bytes(addend, addend94, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum94, sum_data, 32) != 0 || carry94 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend95[32] = {0x02,0xdb,0x3d,0x33,0x84,0x96,0x92,0x28,0x2c,0xc4,0x45,0xc2,0xc3,0x13,0x58,0x4f,0x96,0x54,0xc5,0xd4,0xc6,0xfd,0xcf,0xd4,0x43,0xbf,0x17,0x30,0xc8,0x5d,0x5c,0x16};
    static std::uint8_t addend95[32] = {0x9e,0xce,0x49,0x53,0xca,0xac,0xf2,0xaa,0x8b,0xc5,0x6f,0x72,0x39,0x24,0x7f,0x43,0x6f,0xbb,0x58,0x7d,0x51,0x3a,0x7a,0x9e,0x32,0xe5,0x73,0xbd,0x99,0xb7,0xc6,0x13};
    static std::uint8_t sum95[32]    = {0xa1,0xa9,0x86,0x87,0x4f,0x43,0x84,0xd2,0xb8,0x89,0xb5,0x34,0xfc,0x37,0xd7,0x93,0x06,0x10,0x1e,0x52,0x18,0x38,0x4a,0x72,0x76,0xa4,0x8a,0xee,0x62,0x15,0x22,0x29};
    static int          carry95      = 0;
    mpz_from_bytes(augend, augend95, 4);
    mpz_from_bytes(addend, addend95, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum95, sum_data, 32) != 0 || carry95 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend96[32] = {0x25,0xfe,0x20,0xaf,0xc3,0x2a,0xfd,0x71,0xbc,0xb3,0xf7,0x30,0xb6,0xb3,0x9e,0xc6,0xab,0xc9,0x32,0xce,0xa9,0xe4,0x5f,0xff,0x71,0x74,0xb2,0x6e,0x22,0x73,0x25,0xdf};
    static std::uint8_t addend96[32] = {0x0b,0x1b,0xc6,0x21,0x8a,0x77,0x0f,0x81,0x0d,0x38,0x1f,0xe2,0xc5,0xc5,0x3d,0x9e,0x3a,0x04,0xf3,0xc7,0xda,0x9c,0xd6,0xa7,0x65,0xf5,0x70,0x76,0x80,0x32,0x2e,0xb7};
    static std::uint8_t sum96[32]    = {0x31,0x19,0xe6,0xd1,0x4d,0xa2,0x0c,0xf2,0xc9,0xec,0x17,0x13,0x7c,0x78,0xdc,0x64,0xe5,0xce,0x26,0x96,0x84,0x81,0x36,0xa6,0xd7,0x6a,0x22,0xe4,0xa2,0xa5,0x54,0x96};
    static int          carry96      = 0;
    mpz_from_bytes(augend, augend96, 4);
    mpz_from_bytes(addend, addend96, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum96, sum_data, 32) != 0 || carry96 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend97[32] = {0x46,0x04,0x56,0x80,0xea,0xcb,0xba,0x00,0xa3,0x11,0xd5,0x70,0x22,0x2f,0xe9,0xac,0xcc,0x1e,0x01,0x84,0x0b,0x40,0x7e,0x15,0xa8,0xb5,0xf3,0xf5,0xb9,0x63,0x17,0xd3};
    static std::uint8_t addend97[32] = {0x95,0x1c,0x17,0x64,0x85,0x15,0xb3,0xee,0xf5,0x5a,0x9d,0xe8,0x15,0xed,0x47,0xc6,0x77,0x4e,0x54,0x64,0x53,0xbc,0xdc,0x2c,0x68,0x39,0xa0,0x9b,0xea,0x89,0x55,0xf6};
    static std::uint8_t sum97[32]    = {0xdb,0x20,0x6d,0xe5,0x6f,0xe1,0x6d,0xef,0x98,0x6c,0x73,0x58,0x38,0x1d,0x31,0x73,0x43,0x6c,0x55,0xe8,0x5e,0xfd,0x5a,0x42,0x10,0xef,0x94,0x91,0xa3,0xec,0x6d,0xc9};
    static int          carry97      = 0;
    mpz_from_bytes(augend, augend97, 4);
    mpz_from_bytes(addend, addend97, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum97, sum_data, 32) != 0 || carry97 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend98[32] = {0xb3,0x51,0x71,0x20,0x07,0x71,0xc6,0x95,0xc0,0xef,0x88,0xd8,0x42,0x28,0x8c,0x84,0x2b,0xd9,0x38,0xa4,0x5d,0x74,0x1c,0x4c,0x3f,0x40,0xd0,0xe4,0x0d,0xcc,0xaa,0xc0};
    static std::uint8_t addend98[32] = {0x2c,0x64,0xcd,0x6d,0xc7,0xab,0x2d,0x35,0xb5,0xd9,0x2d,0x5e,0x7c,0xe4,0x96,0xe4,0x32,0x80,0xcb,0x52,0x6c,0xc9,0x3b,0x27,0xd9,0x61,0x49,0xd0,0xaf,0xd3,0xd7,0x80};
    static std::uint8_t sum98[32]    = {0xdf,0xb6,0x3e,0x8d,0xcf,0x1c,0xf3,0xcb,0x76,0xc8,0xb6,0x36,0xbf,0x0d,0x23,0x68,0x5e,0x5a,0x03,0xf6,0xca,0x3d,0x57,0x74,0x18,0xa2,0x1a,0xb4,0xbd,0xa0,0x82,0x40};
    static int          carry98      = 0;
    mpz_from_bytes(augend, augend98, 4);
    mpz_from_bytes(addend, addend98, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum98, sum_data, 32) != 0 || carry98 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }

    static std::uint8_t augend99[32] = {0x68,0x47,0x36,0x4b,0x93,0x28,0x53,0xb0,0x8e,0xec,0xad,0x39,0x9e,0x07,0xd3,0xf4,0xf1,0xf0,0x26,0xf0,0x44,0x73,0x85,0x5f,0x3f,0xf7,0x49,0x11,0x7d,0x63,0x82,0x99};
    static std::uint8_t addend99[32] = {0xcf,0xca,0x34,0x95,0x09,0x08,0x31,0x21,0x8f,0x42,0x8c,0x9a,0x2d,0xd8,0xa8,0x61,0x2f,0x1e,0x87,0xec,0xa4,0x9e,0xdd,0x5d,0x1f,0xbb,0xec,0xbb,0x8e,0xc3,0x4d,0x26};
    static std::uint8_t sum99[32]    = {0x38,0x11,0x6a,0xe0,0x9c,0x30,0x84,0xd2,0x1e,0x2f,0x39,0xd3,0xcb,0xe0,0x7c,0x56,0x21,0x0e,0xae,0xdc,0xe9,0x12,0x62,0xbc,0x5f,0xb3,0x35,0xcd,0x0c,0x26,0xcf,0xbf};
    static int          carry99      = 1;
    mpz_from_bytes(augend, augend99, 4);
    mpz_from_bytes(addend, addend99, 4);
    carry = mpz_add_carry(sum, augend, addend, 0, 4);
    mpz_to_bytes(sum_data, sum, 4);
    if (std::memcmp(sum99, sum_data, 32) != 0 || carry99 != carry)
    {
        throw std::runtime_error("err in x64::mpz_add_carry");
    }
}
#else
void test_mpz_x64_add_carry()
{
}
#endif